From 91cd70582d2af5c6353505c6956644818cb2387f Mon Sep 17 00:00:00 2001 From: Yiming Lv Date: Fri, 7 Jun 2024 12:57:59 +0000 Subject: [PATCH 0001/1485] set tx power for sar Signed-off-by: Yiming Lv --- wlan/chip/hdi_service/wifi_ap_iface.cpp | 8 +++++++- wlan/chip/hdi_service/wifi_p2p_iface.cpp | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_ap_iface.cpp b/wlan/chip/hdi_service/wifi_ap_iface.cpp index b7b4c6c1b5..54adc50614 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.cpp +++ b/wlan/chip/hdi_service/wifi_ap_iface.cpp @@ -169,7 +169,13 @@ int32_t WifiApIface::SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enabl int32_t WifiApIface::SetTxPower(int32_t power) { - return HDF_ERR_NOT_SUPPORT; +{ + WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power); + if (status == HAL_SUCCESS) { + return HDF_SUCCESS; + } + return HDF_FAILURE; +} } } diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.cpp b/wlan/chip/hdi_service/wifi_p2p_iface.cpp index 511be1e764..eabcfc8b5a 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.cpp +++ b/wlan/chip/hdi_service/wifi_p2p_iface.cpp @@ -133,7 +133,13 @@ int32_t WifiP2pIface::SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enab int32_t WifiP2pIface::SetTxPower(int32_t power) { - return HDF_ERR_NOT_SUPPORT; +{ + WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power); + if (status == HAL_SUCCESS) { + return HDF_SUCCESS; + } + return HDF_FAILURE; +} } } -- Gitee From 7a366c770fa048d781e8fdd031ce1412e4fde6f7 Mon Sep 17 00:00:00 2001 From: Yiming Lv Date: Thu, 13 Jun 2024 02:02:38 +0000 Subject: [PATCH 0002/1485] bugfix Signed-off-by: Yiming Lv --- wlan/chip/hdi_service/wifi_ap_iface.cpp | 5 +---- wlan/chip/hdi_service/wifi_p2p_iface.cpp | 5 +---- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_ap_iface.cpp b/wlan/chip/hdi_service/wifi_ap_iface.cpp index 54adc50614..3352021ade 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.cpp +++ b/wlan/chip/hdi_service/wifi_ap_iface.cpp @@ -171,10 +171,7 @@ int32_t WifiApIface::SetTxPower(int32_t power) { { WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power); - if (status == HAL_SUCCESS) { - return HDF_SUCCESS; - } - return HDF_FAILURE; + return status; } } diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.cpp b/wlan/chip/hdi_service/wifi_p2p_iface.cpp index eabcfc8b5a..2512b2f902 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.cpp +++ b/wlan/chip/hdi_service/wifi_p2p_iface.cpp @@ -135,10 +135,7 @@ int32_t WifiP2pIface::SetTxPower(int32_t power) { { WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power); - if (status == HAL_SUCCESS) { - return HDF_SUCCESS; - } - return HDF_FAILURE; + return status; } } -- Gitee From 0deac201f4e305a4ad19b83a89bc6611f1bcf002 Mon Sep 17 00:00:00 2001 From: liuziwei Date: Thu, 18 Jul 2024 11:09:24 +0800 Subject: [PATCH 0003/1485] fix code Signed-off-by: liuziwei --- pin_auth/hdi_service/service/src/all_in_one_impl.cpp | 9 +++++---- pin_auth/hdi_service/service/src/collector_impl.cpp | 5 +++-- .../pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp | 2 +- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/pin_auth/hdi_service/service/src/all_in_one_impl.cpp b/pin_auth/hdi_service/service/src/all_in_one_impl.cpp index 52b9be2a2e..081278a86d 100644 --- a/pin_auth/hdi_service/service/src/all_in_one_impl.cpp +++ b/pin_auth/hdi_service/service/src/all_in_one_impl.cpp @@ -146,7 +146,8 @@ int32_t AllInOneImpl::Enroll(uint64_t scheduleId, const std::vector &ex } std::vector challenge; - result = callbackObj->OnGetData(algoParameter, 0, algoVersion, challenge); + std::vector pinComplexityReg; + result = callbackObj->OnGetData(algoParameter, 0, algoVersion, challenge, pinComplexityReg); if (result != SUCCESS) { IAM_LOGE("Enroll Pin failed, fail code : %{public}d", result); CallError(callbackObj, GENERAL_ERROR); @@ -218,9 +219,9 @@ int32_t AllInOneImpl::Authenticate(uint64_t scheduleId, const std::vector challenge; - result = callbackObj->OnGetData( - pinAlgoParam.algoParameter, pinAlgoParam.subType, pinAlgoParam.algoVersion, pinAlgoParam.challenge); + std::vector pinComplexityReg; + result = callbackObj->OnGetData(pinAlgoParam.algoParameter, pinAlgoParam.subType, pinAlgoParam.algoVersion, + pinAlgoParam.challenge, pinComplexityReg); if (result != SUCCESS) { IAM_LOGE("Authenticate Pin failed, fail code : %{public}d", result); CallError(callbackObj, GENERAL_ERROR); diff --git a/pin_auth/hdi_service/service/src/collector_impl.cpp b/pin_auth/hdi_service/service/src/collector_impl.cpp index 72189e3f52..9c7313b1f3 100644 --- a/pin_auth/hdi_service/service/src/collector_impl.cpp +++ b/pin_auth/hdi_service/service/src/collector_impl.cpp @@ -139,8 +139,9 @@ int32_t CollectorImpl::SendMessage(uint64_t scheduleId, int32_t srcRole, const s IAM_LOGE("Hdi SendMessageToCollector fail"); return; } - if (callback_->OnGetData(pinAlgoParam.algoParameter, pinAlgoParam.subType, - pinAlgoParam.algoVersion, pinAlgoParam.challenge) != SUCCESS) { + std::vector pinComplexityReg; + if (callback_->OnGetData(pinAlgoParam.algoParameter, pinAlgoParam.subType, pinAlgoParam.algoVersion, + pinAlgoParam.challenge, pinComplexityReg) != SUCCESS) { IAM_LOGE("Hdi callback OnGetData fail"); CancelCurrentCollect(); } diff --git a/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp b/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp index 93b66fdcc7..543b35eefd 100644 --- a/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp +++ b/pin_auth/test/fuzztest/pin_auth/pinauthhdi_fuzzer/pin_auth_hdi_fuzzer.cpp @@ -52,7 +52,7 @@ public: } int32_t OnGetData(const std::vector& algoParameter, uint64_t authSubType, uint32_t algoVersion, - const std::vector& challenge) override + const std::vector& challenge, const std::vector& pinComplexityReg) override { return onGetDataResult_; } -- Gitee From 6b47e9392b7569f4dc020eb5712f221815c36f89 Mon Sep 17 00:00:00 2001 From: qinjihong Date: Sat, 27 Jul 2024 14:34:26 +0800 Subject: [PATCH 0004/1485] add length param Signed-off-by: qinjihong --- usb/hdi_service/include/usb_impl.h | 2 ++ usb/hdi_service/src/usb_impl.cpp | 43 ++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index 171798d196..1b25945be6 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -66,6 +66,8 @@ public: int32_t ControlTransferRead(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector &data) override; int32_t ControlTransferWrite( const UsbDev &dev, const UsbCtrlTransfer &ctrl, const std::vector &data) override; + int32_t ControlTransferReadwithLength( + const UsbDev &dev, const UsbCtrlTransferParams &ctrlParams, std::vector &data) override; int32_t InterruptTransferRead( const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector &data) override; int32_t InterruptTransferWrite( diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index bc586eaffc..6f46c7a9c7 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1620,6 +1620,49 @@ int32_t UsbImpl::ControlTransferWrite(const UsbDev &dev, const UsbCtrlTransfer & return ret; } +int32_t UsbImpl::ControlTransferReadwithLength( + const UsbDev &dev, const UsbCtrlTransferParams &ctrlParams, std::vector &data) +{ + if ((static_cast(ctrlParams.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) { + HDF_LOGE("%{public}s: this function is read, not write", __func__); + return HDF_FAILURE; + } + + HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); + if (port == nullptr || port->ctrDevHandle == nullptr) { + HDF_LOGE("%{public}s:FindDevFromService failed", __func__); + return HDF_DEV_ERR_NO_DEVICE; + } + + UsbControlParams controlParams; + if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) { + HDF_LOGE("%{public}s:memset_s failed ", __func__); + return HDF_FAILURE; + } + controlParams.request = static_cast(ctrlParams.requestCmd); + controlParams.value = ctrlParams.value; + controlParams.index = ctrlParams.index; + controlParams.target = (UsbRequestTargetType)(static_cast(ctrlParams.requestType) & USB_RECIP_MASK); + controlParams.directon = (UsbRequestDirection)(((static_cast(ctrlParams.requestType)) + >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK); + controlParams.reqType = static_cast(ctrlParams.requestType); + controlParams.size = ctrlParams.length; + controlParams.data = static_cast(OsalMemCalloc(controlParams.size)); + if (controlParams.data == nullptr) { + HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + int32_t ret = UsbControlTransferEx(port, &controlParams, ctrlParams.timeout); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret); + } + + uint8_t *dataValue = static_cast(controlParams.data); + data.assign(dataValue, dataValue + controlParams.size); + OsalMemFree(controlParams.data); + return ret; +} + int32_t UsbImpl::InterruptTransferRead( const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector &data) { -- Gitee From de0e3103f2dd003ffda2ba36b08dde272fb6d53d Mon Sep 17 00:00:00 2001 From: luzhiye Date: Tue, 30 Jul 2024 09:16:31 +0000 Subject: [PATCH 0005/1485] =?UTF-8?q?usb=E5=86=85=E5=AD=98=E6=B3=84?= =?UTF-8?q?=E6=BC=8F=E9=97=AE=E9=A2=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 2 ++ usb/gadget/function/acm/cdcacm.c | 1 + usb/serial/src/usb_serial_rawapi.c | 1 + 3 files changed, 4 insertions(+) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 7c0411f115..83457276a1 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -375,11 +375,13 @@ static int32_t UsbFnAdapterDelInterface(const char *interfaceName, int32_t nameL ret = snprintf_s(fnnew.name, MAX_NAMELEN, MAX_NAMELEN - 1, "%s", interfaceName); if (ret < 0) { HDF_LOGE("%{public}s: snprintf_s failed", __func__); + UsbFnAdapterClosefn(fd); return HDF_ERR_IO; } ret = ioctl(fd, FUNCTIONFS_DELFN, &fnnew); if (ret != 0) { HDF_LOGE("%{public}s: FUNCTIONFS_DELFN failed", __func__); + UsbFnAdapterClosefn(fd); return HDF_ERR_IO; } ret = UsbFnAdapterClosefn(fd); diff --git a/usb/gadget/function/acm/cdcacm.c b/usb/gadget/function/acm/cdcacm.c index 3bdd71eefb..4132abe9e4 100644 --- a/usb/gadget/function/acm/cdcacm.c +++ b/usb/gadget/function/acm/cdcacm.c @@ -1474,6 +1474,7 @@ static int32_t UsbSerialAlloc(struct UsbAcmDevice *acm) if (OsalMutexInit(&port->lock) != HDF_SUCCESS) { HDF_LOGE("%{public}s: init lock fail!", __func__); + OsalMemFree(port); return HDF_FAILURE; } diff --git a/usb/serial/src/usb_serial_rawapi.c b/usb/serial/src/usb_serial_rawapi.c index 0d6800c06c..682d6831b7 100644 --- a/usb/serial/src/usb_serial_rawapi.c +++ b/usb/serial/src/usb_serial_rawapi.c @@ -510,6 +510,7 @@ static int32_t UsbSerialDeviceAlloc(struct AcmDevice *acm) } if (OsalMutexInit(&port->lock) != HDF_SUCCESS) { HDF_LOGE("%{public}s: init lock fail!", __func__); + OsalMemFree(port); return HDF_FAILURE; } port->lineCoding.dwDTERate = CPU_TO_LE32(DATARATE); -- Gitee From d2c6fa43df4031b9b0aa76e7d503a656278350d2 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Tue, 30 Jul 2024 09:19:52 +0000 Subject: [PATCH 0006/1485] =?UTF-8?q?usb=E7=A9=BA=E6=8C=87=E9=92=88?= =?UTF-8?q?=E9=97=AE=E9=A2=98=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/serial/src/usb_serial_rawapi.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/usb/serial/src/usb_serial_rawapi.c b/usb/serial/src/usb_serial_rawapi.c index 0d6800c06c..d0ea6eb5fe 100644 --- a/usb/serial/src/usb_serial_rawapi.c +++ b/usb/serial/src/usb_serial_rawapi.c @@ -1198,6 +1198,10 @@ static void UsbFreeReadRequests(struct AcmDevice *acm) static int32_t UsbAllocNotifyRequest(struct AcmDevice *acm) { struct UsbRawFillRequestData fillRequestData; + if ((acm == NULL) || (acm->notifyEp == NULL)) { + HDF_LOGE("%{public}s: acm or notifyEp is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } uint32_t size = acm->notifyEp->maxPacketSize; int32_t ret; -- Gitee From 00460a62d8d0eed6c5b01ebcfe5b3a9188e5691c Mon Sep 17 00:00:00 2001 From: wenjunhu_28fe Date: Mon, 29 Jul 2024 13:02:10 +0800 Subject: [PATCH 0007/1485] add BOSCH BMI270 acc/gyro hdf driver. Signed-off-by:wenjunhu_28fe --- sensor/chipset/accel/accel_bmi270.c | 439 ++++++++++++++++++++++++++++ sensor/chipset/accel/accel_bmi270.h | 109 +++++++ sensor/chipset/gyro/gyro_bmi270.c | 439 ++++++++++++++++++++++++++++ sensor/chipset/gyro/gyro_bmi270.h | 97 ++++++ 4 files changed, 1084 insertions(+) create mode 100644 sensor/chipset/accel/accel_bmi270.c create mode 100644 sensor/chipset/accel/accel_bmi270.h create mode 100644 sensor/chipset/gyro/gyro_bmi270.c create mode 100644 sensor/chipset/gyro/gyro_bmi270.h diff --git a/sensor/chipset/accel/accel_bmi270.c b/sensor/chipset/accel/accel_bmi270.c new file mode 100644 index 0000000000..03677cb148 --- /dev/null +++ b/sensor/chipset/accel/accel_bmi270.c @@ -0,0 +1,439 @@ +/** +* Copyright (c) 2024 Bosch Sensortec GmbH. All rights reserved. +* +* accel_bmi270.c as part of the * /chipsets subdirectory +* is dual licensed: you can use it either under the terms of +* the GPL, or the BSD license, at your option. +* See the LICENSE file in the root of this repository for complete details. +*/ + +#include "accel_bmi270.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_accel_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" + +#define HDF_LOG_TAG khdf_sensor_accel_driver +static struct Bmi270DrvData *g_bmi270DrvData = NULL; +//328 bytes +static uint8_t g_regw_buffer[512]; + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static uint8_t bmi270_cfg_buffer[] = { + 0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0x1a, 0x00, 0xc8, 0x2e, 0x00, 0x2e, + 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, + 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, 0x90, 0x32, 0x21, 0x2e, + 0x59, 0xf5, 0x10, 0x30, 0x21, 0x2e, 0x6a, 0xf5, 0x1a, 0x24, 0x22, 0x00, + 0x80, 0x2e, 0x3b, 0x00, 0xc8, 0x2e, 0x44, 0x47, 0x22, 0x00, 0x37, 0x00, + 0xa4, 0x00, 0xff, 0x0f, 0xd1, 0x00, 0x07, 0xad, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x24, + 0xfc, 0xf5, 0x80, 0x30, 0x40, 0x42, 0x50, 0x50, 0x00, 0x30, 0x12, 0x24, + 0xeb, 0x00, 0x03, 0x30, 0x00, 0x2e, 0xc1, 0x86, 0x5a, 0x0e, 0xfb, 0x2f, + 0x21, 0x2e, 0xfc, 0xf5, 0x13, 0x24, 0x63, 0xf5, 0xe0, 0x3c, 0x48, 0x00, + 0x22, 0x30, 0xf7, 0x80, 0xc2, 0x42, 0xe1, 0x7f, 0x3a, 0x25, 0xfc, 0x86, + 0xf0, 0x7f, 0x41, 0x33, 0x98, 0x2e, 0xc2, 0xc4, 0xd6, 0x6f, 0xf1, 0x30, + 0xf1, 0x08, 0xc4, 0x6f, 0x11, 0x24, 0xff, 0x03, 0x12, 0x24, 0x00, 0xfc, + 0x61, 0x09, 0xa2, 0x08, 0x36, 0xbe, 0x2a, 0xb9, 0x13, 0x24, 0x38, 0x00, + 0x64, 0xbb, 0xd1, 0xbe, 0x94, 0x0a, 0x71, 0x08, 0xd5, 0x42, 0x21, 0xbd, + 0x91, 0xbc, 0xd2, 0x42, 0xc1, 0x42, 0x00, 0xb2, 0xfe, 0x82, 0x05, 0x2f, + 0x50, 0x30, 0x21, 0x2e, 0x21, 0xf2, 0x00, 0x2e, 0x00, 0x2e, 0xd0, 0x2e, + 0xf0, 0x6f, 0x02, 0x30, 0x02, 0x42, 0x20, 0x26, 0xe0, 0x6f, 0x02, 0x31, + 0x03, 0x40, 0x9a, 0x0a, 0x02, 0x42, 0xf0, 0x37, 0x05, 0x2e, 0x5e, 0xf7, + 0x10, 0x08, 0x12, 0x24, 0x1e, 0xf2, 0x80, 0x42, 0x83, 0x84, 0xf1, 0x7f, + 0x0a, 0x25, 0x13, 0x30, 0x83, 0x42, 0x3b, 0x82, 0xf0, 0x6f, 0x00, 0x2e, + 0x00, 0x2e, 0xd0, 0x2e, 0x12, 0x40, 0x52, 0x42, 0x00, 0x2e, 0x12, 0x40, + 0x52, 0x42, 0x3e, 0x84, 0x00, 0x40, 0x40, 0x42, 0x7e, 0x82, 0xe1, 0x7f, + 0xf2, 0x7f, 0x98, 0x2e, 0x6a, 0xd6, 0x21, 0x30, 0x23, 0x2e, 0x61, 0xf5, + 0xeb, 0x2c, 0xe1, 0x6f +}; +//328 bytes + +static struct Bmi270DrvData *Bmi270GetDrvData(void) +{ + return g_bmi270DrvData; +} + +/// @brief basic register write function +/// @param data Sensor configuration data structre pointer +/// @param rega register address +/// @param buffer value to write +/// @param len write len +/// @return HDF_SUCCESS if success, failed any error +static int32_t AccBmi270HalRegWrite(struct SensorCfgData *data, uint16_t rega, uint8_t* buffer, uint32_t len) +{ + int32_t rc = HDF_SUCCESS; + uint32_t idx = 0; + (void)memset_s(g_regw_buffer, sizeof(g_regw_buffer), 0, sizeof(g_regw_buffer)); + + g_regw_buffer[0] = (rega & 0xFF); + do { + g_regw_buffer[idx + 1] = buffer[idx]; + idx ++; + } while (idx < len); + + rc = WriteSensor(&data->busCfg, g_regw_buffer, (len + 1)); + OsalUDelay(BMI270_LP_MODE_WRITE_DELAY_IN_US); + + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] w reg:%d err", __func__, rega); + } + + return rc; +} + +/// @brief basic register read function +/// @param data Sensor configuration data structre pointer +/// @param rega register address to read +/// @param buffer read data buffer +/// @param len read len +/// @return HDF_SUCCESS if success, failed any error +static int32_t AccBmi270HalRegRead(struct SensorCfgData *data, uint16_t rega, uint8_t* buffer, uint32_t len) +{ + int32_t rc = HDF_SUCCESS; + rc = ReadSensor(&data->busCfg, rega, buffer, len); + + OsalUDelay(BMI270_NORMAL_MODE_WRITE_DELAY_IN_US); + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] r reg:%d err", __func__, rega); + } + + return rc; +} + +static int32_t AccReadBmi270RawData(struct SensorCfgData *data, struct AccelData *rawData, int64_t *timestamp) +{ + OsalTimespec time; + uint8_t status = 0; + uint8_t regv[ACCEL_AXIS_BUTT] = {0}; + int32_t ret = HDF_SUCCESS; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + (void)memset_s(regv, sizeof(regv), 0, sizeof(regv)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + + ret = AccBmi270HalRegRead(data, BMI270_ACCEL_REGA_STATUS, &status, sizeof(uint8_t)); + /* any new data? */ + if (!(status & BMI270_ACCEL_DATA_READY_MASK) || (ret != HDF_SUCCESS)) { + HDF_LOGI("%s: data status [%hhu] ret [%d]", __func__, status, ret); + return HDF_FAILURE; + } + + ret = AccBmi270HalRegRead(data, BMI270_ACCEL_REGA_X_LSB_ADDR, regv, BMI270_ACC_DATA_FRAME_SIZE); + + rawData->x = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[ACCEL_X_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[ACCEL_X_AXIS_LSB]); + rawData->y = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[ACCEL_Y_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[ACCEL_Y_AXIS_LSB]); + rawData->z = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[ACCEL_Z_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[ACCEL_Z_AXIS_LSB]); + + return ret; +} + +static int32_t AccReadBmi270Data(struct SensorCfgData *cfg, struct SensorReportEvent *event) +{ + int32_t ret; + struct AccelData rawData = { 0, 0, 0 }; + static int32_t tmp[ACCEL_AXIS_NUM]; + + CHECK_NULL_PTR_RETURN_VALUE(cfg, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(event, HDF_ERR_INVALID_PARAM); + + ret = AccReadBmi270RawData(cfg, &rawData, (int64_t *)&event->timestamp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 read raw data failed", __func__); + return HDF_FAILURE; + } + event->sensorId = SENSOR_TAG_ACCELEROMETER; + event->option = 0; + event->mode = SENSOR_WORK_MODE_REALTIME; + + rawData.x = rawData.x * BMI270_ACC_SENSITIVITY_2G; + rawData.y = rawData.y * BMI270_ACC_SENSITIVITY_2G; + rawData.z = rawData.z * BMI270_ACC_SENSITIVITY_2G; + + tmp[ACCEL_X_AXIS] = (rawData.x * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + tmp[ACCEL_Y_AXIS] = (rawData.y * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + tmp[ACCEL_Z_AXIS] = (rawData.z * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + + + ret = SensorRawDataToRemapData(cfg->direction, tmp, sizeof(tmp) / sizeof(tmp[0])); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 convert raw data failed", __func__); + return HDF_FAILURE; + } + + event->dataLen = sizeof(tmp); + event->data = (uint8_t *)&tmp; + + return ret; +} + +// success +static int32_t Bmi270IMUSwReset(struct SensorCfgData* data) +{ + uint8_t regv = BMI26X_REGV_CMD_SOFT_RESET; + int32_t rc = AccBmi270HalRegWrite(data, BMI26X_REGA_USR_CMD, ®v, BMI270_ONE_BYTE); + OsalMDelay(BMI270_RESET_DELAY_IN_MS); + + return rc; +} + +static bool Bmi270HalIMUInited(struct SensorCfgData *data) +{ + bool rc = false; + uint8_t regv = 0; + + rc = AccBmi270HalRegRead(data, BMI270_REGA_INTERNAL_STATUS, ®v, BMI270_ONE_BYTE); + if (BST_GET_VAL_BIT(regv, 0)) { + HDF_LOGI("[BMI270] %s, IMU inited", __LINE__); + rc = true; + } + + return rc; +} + +static int32_t Bmi270CfgAccPwr(struct SensorCfgData *data, bool en) +{ + uint8_t regv = 0; + int32_t rc = HDF_SUCCESS; + rc = AccBmi270HalRegRead(data, BMI270_REGA_PWR_CTRL, ®v, BMI270_ONE_BYTE); + + if (en) { + regv = BST_SET_VAL_BIT(regv, BMI270_ACC_POWER_BIT_POS_IN_PWR_CTRL_REG); + } else { + regv = BST_CLR_VAL_BIT(regv, BMI270_ACC_POWER_BIT_POS_IN_PWR_CTRL_REG); + } + + rc = AccBmi270HalRegWrite(data, BMI270_REGA_PWR_CTRL, ®v, BMI270_ONE_BYTE); + + return rc; +} + +// @load configuration +static int32_t Bmi270LoadCfg(struct SensorCfgData *data, uint8_t* cfg_data_buffer, + uint32_t cfg_size, uint32_t in_burst_write_size) +{ + int32_t rc = HDF_SUCCESS; + uint8_t regv = 0; + /* Variable to update the configuration file index */ + uint16_t index = 0; + /* Array to store address */ + uint8_t addr_array[2] = {0}; + uint32_t size_bw = in_burst_write_size; //burst write size in byte + + /* Disable loading of the configuration */ + rc = AccBmi270HalRegWrite(data, BMI26X_REGA_USR_TITAN_CTRL, ®v, BMI270_ONE_BYTE); + + for (index = 0; index < cfg_size; index += size_bw) { + //1. len + if (index + in_burst_write_size > cfg_size) { + size_bw = cfg_size - index; + } + + // index low in word + addr_array[0] = (uint8_t)((index / 2) & 0x0F); + // ndex high in word + addr_array[1] = (uint8_t)((index / 2) >> 4); + rc = AccBmi270HalRegWrite(data, BMI26X_REGA_USR_CONF_STREAM_IDX_LSB, addr_array, BMI270_TWO_BYTE); + + //2. data + rc = AccBmi270HalRegWrite(data, BMI26X_REGA_USR_CONF_STREAM_IN, + cfg_data_buffer + index, size_bw); + } + + return rc; +} + +static int32_t Bmi270HalLoadCfg(struct SensorCfgData *data) +{ + int32_t rc = HDF_SUCCESS; + uint8_t regv = 0; + uint8_t try_num_to_check_cfg = 0; + bool cfg_is_avaiblabe = Bmi270HalIMUInited(data); + if (cfg_is_avaiblabe) { + return HDF_SUCCESS; + } + + rc = Bmi270IMUSwReset(data); + if (rc != HDF_SUCCESS) { + return rc; + } + + //disable advance power saving + rc = AccBmi270HalRegWrite(data, BMI270_REGA_PWR_CFG, ®v, BMI270_ONE_BYTE); + + // load configuration now + rc = Bmi270LoadCfg(data, bmi270_cfg_buffer, + HDF_ARRAY_SIZE(bmi270_cfg_buffer), + HDF_ARRAY_SIZE(bmi270_cfg_buffer)); + + regv = 0x01; + rc = AccBmi270HalRegWrite(data, BMI26X_REGA_USR_TITAN_CTRL, ®v, BMI270_ONE_BYTE); + + cfg_is_avaiblabe = false; + rc = HDF_DEV_ERR_DEV_INIT_FAIL; + do { + OsalMDelay(BMI270_LOAD_RAM_PATCH_DELAY_IN_MS); + cfg_is_avaiblabe = Bmi270HalIMUInited(data); + try_num_to_check_cfg ++; + if (cfg_is_avaiblabe) { + rc = HDF_SUCCESS; + break; + } + } while ((try_num_to_check_cfg < BMI26X_CHECK_CONFIGURE_STATUS_TIMES) && + (!cfg_is_avaiblabe)); + + return rc; +} + +static int32_t Bmi270GetWhoAmI(struct SensorCfgData *data) +{ + uint8_t regv = 0; + int32_t rc = HDF_SUCCESS; + + rc = AccBmi270HalRegRead(data, 0x00, ®v, BMI270_ONE_BYTE); + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] WARN!!, NO Sensor", __func__); + return HDF_FAILURE; + } + + if (regv != BMI26X_REGV_WHOAMI) { + rc = HDF_DEV_ERR_NO_DEVICE; + } + + return rc; +} + +static int32_t InitBmi270(struct SensorCfgData *data) +{ + int32_t ret = HDF_SUCCESS; + uint8_t regv = 0x00; + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 sensor init config failed", __func__); + return HDF_FAILURE; + } + + ret = Bmi270CfgAccPwr(data, true); + //defualt odr:100hz + // range:+/- 2G + regv = 0; + ret = AccBmi270HalRegWrite(data, BMI26X_REGA_ACC_RANGE, ®v, BMI270_ONE_BYTE); + + return ret; +} + +static int32_t DispatchBmi270(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +static int32_t Bmi270BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Bmi270 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBmi270; + drvData->device = device; + device->service = &drvData->ioService; + g_bmi270DrvData = drvData; + + return HDF_SUCCESS; +} + +static int32_t Bmi270InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct AccelOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->sensorCfg = AccelCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating accelcfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = AccReadBmi270Data; + ret = AccelRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register BMI270 accel failed", __func__); + return HDF_FAILURE; + } + + // check whoami + ret = Bmi270GetWhoAmI(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + return ret; + } + + do { + ret = Bmi270HalLoadCfg(drvData->sensorCfg); + } while (0); + + // init hw + ret = InitBmi270(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BMI270 accel failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static void Bmi270ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + AccelReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_accelBmi270DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_ACCEL_BMI270", + .Bind = Bmi270BindDriver, + .Init = Bmi270InitDriver, + .Release = Bmi270ReleaseDriver, +}; + +HDF_INIT(g_accelBmi270DevEntry); diff --git a/sensor/chipset/accel/accel_bmi270.h b/sensor/chipset/accel/accel_bmi270.h new file mode 100644 index 0000000000..df6da61020 --- /dev/null +++ b/sensor/chipset/accel/accel_bmi270.h @@ -0,0 +1,109 @@ +/** +* Copyright (c) 2024 Bosch Sensortec GmbH. All rights reserved. +* +* accel_bmi270.h as part of the * /chipsets subdirectory +* is dual licensed: you can use it either under the terms of +* the GPL, or the BSD license, at your option. +* See the LICENSE file in the root of this repository for complete details. +*/ + +#ifndef ACC_BMI270_H +#define ACC_BMI270_H + +#include "sensor_accel_driver.h" +#include "sensor_config_parser.h" + +#define BMI270_ACC_DATA_FRAME_SIZE 6 +#define BMI270_ONE_BYTE sizeof(uint8_t) +#define BMI270_TWO_BYTE sizeof(uint16_t) + +// bus operation delay +#define BMI270_NORMAL_MODE_WRITE_DELAY_IN_US 4 +#define BMI270_LP_MODE_WRITE_DELAY_IN_US 460 + +// feature operation delay +#define BMI270_RESET_DELAY_IN_MS 5 +#define BMI270_LOAD_RAM_PATCH_DELAY_IN_MS 10 + +// bit definition +#define BMI270_ACC_POWER_BIT_POS_IN_PWR_CTRL_REG 2 + +#define BST_GET_VAL_BIT(val, bit) (((val) >> (bit)) & 0x01) +#define BST_GET_VAL_BITBLOCK(val, start, end) (((val) >> (start)) & ((1 << (end - start + 1))-1)) + +#define BST_SET_VAL_BIT(val, bit) (val | (1 << (bit))) +#define BST_CLR_VAL_BIT(val, bit) (val & (~(1 << (bit)))) + +#define BMI270_ACCEL_REGA_STATUS 0X03 +#define BMI270_ACCEL_REGA_X_LSB_ADDR 0X0C +#define BMI270_ACCEL_REGA_X_MSB_ADDR 0X0D +#define BMI270_ACCEL_REGA_Y_LSB_ADDR 0X0E +#define BMI270_ACCEL_REGA_Y_MSB_ADDR 0X0F +#define BMI270_ACCEL_REGA_Z_LSB_ADDR 0X10 +#define BMI270_ACCEL_REGA_Z_MSB_ADDR 0X11 +#define BMI270_ACCEL_REGA_INT_STATUS 0X1D + +/* ACCEL ODR */ +#define BMI270_ACCEL_REGA_ODR_RESERVED 0x00 +#define BMI270_ACCEL_REGA_ODR_0_78HZ 0x01 +#define BMI270_ACCEL_REGA_ODR_1_56HZ 0x02 +#define BMI270_ACCEL_REGA_ODR_3_12HZ 0x03 +#define BMI270_ACCEL_REGA_ODR_6_25HZ 0x04 +#define BMI270_ACCEL_REGA_ODR_12_5HZ 0x05 +#define BMI270_ACCEL_REGA_ODR_25HZ 0x06 +#define BMI270_ACCEL_REGA_ODR_50HZ 0x07 +#define BMI270_ACCEL_REGA_ODR_100HZ 0x08 +#define BMI270_ACCEL_REGA_ODR_200HZ 0x09 +#define BMI270_ACCEL_REGA_ODR_400HZ 0x0A +#define BMI270_ACCEL_REGA_ODR_800HZ 0x0B +#define BMI270_ACCEL_REGA_ODR_1600HZ 0x0C +#define BMI270_ACCEL_REGA_ODR_RESERVED0 0x0D +#define BMI270_ACCEL_REGA_ODR_RESERVED1 0x0E +#define BMI270_ACCEL_REGA_ODR_RESERVED2 0x0F + + +#define BMI270_REGA_INTERNAL_STATUS 0x21 + +#define BMI26X_REGA_ACC_ODR 0x40 +#define BMI26X_REGA_ACC_RANGE 0x41 +#define BMI26X_REGA_USR_ERR_REG_MASK 0x52 +#define BMI26X_REGA_USR_INT1_IO_CTRL 0x53 +#define BMI26X_REGA_USR_INT2_IO_CTRL 0x54 +#define BMI26X_REGA_USR_INT_LATCH 0x55 +#define BMI26X_REGA_USR_INT1_MAP 0x56 +#define BMI26X_REGA_USR_INT2_MAP 0x57 +#define BMI26X_REGA_USR_INT_MAP_HW 0x58 +#define BMI26X_REGA_USR_TITAN_CTRL 0x59 +#define BMI26X_REGA_USR_CONF_STREAM_IDX_LSB 0x5b +#define BMI26X_REGA_USR_CONF_STREAM_IN 0x5e +#define BMI26X_REGA_USR_INTERNAL_ERROR 0x5f + +#define BMI270_REGA_PWR_CFG 0x7C +#define BMI270_REGA_PWR_CTRL 0x7D +#define BMI26X_REGA_USR_CMD 0x7E + +#define BMI26X_REGV_WHOAMI 0x24 +#define BMI26X_REGV_CMD_SOFT_RESET 0xB6 + +/* default HZ */ +#define BMI270_ACCEL_DEFAULT_ODR_100HZ 100 /*hw defualt value @0x8*/ +#define BMI270_ACCEL_DEFAULT_ODR_25HZ 25 + +#define BMI26X_CHECK_CONFIGURE_STATUS_TIMES 15 +#define BMI270_ACCEL_DATA_READY_MASK 0x80 + +#define BMI270_ACC_ODR_FILTER_DEFAULT 0xA0 + +/* ACC sensitivity */ +#define BMI270_ACC_SENSITIVITY_2G 61 +#define BMI270_ACC_SENSITIVITY_4G 122 +#define BMI270_ACC_SENSITIVITY_8G 244 +#define BMI270_ACC_SENSITIVITY_16G 488 + +struct Bmi270DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + +#endif /* ACC_BMI270_H */ diff --git a/sensor/chipset/gyro/gyro_bmi270.c b/sensor/chipset/gyro/gyro_bmi270.c new file mode 100644 index 0000000000..75f56d8367 --- /dev/null +++ b/sensor/chipset/gyro/gyro_bmi270.c @@ -0,0 +1,439 @@ +/** +* Copyright (c) 2024 Bosch Sensortec GmbH. All rights reserved. +* +* gyro_bmi270.c as part of the * /chipsets subdirectory +* is dual licensed: you can use it either under the terms of +* the GPL, or the BSD license, at your option. +* See the LICENSE file in the root of this repository for complete details. +*/ + +#include "gyro_bmi270.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_gyro_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" + +#define HDF_LOG_TAG khdf_sensor_gyro_driver +static struct Bmi270DrvData *g_bmi270DrvData = NULL; +static uint8_t g_regw_buffer[512]; + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static uint8_t bmi270_cfg_buffer[] = { + 0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0x1a, 0x00, 0xc8, 0x2e, 0x00, 0x2e, + 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, + 0xc8, 0x2e, 0x00, 0x2e, 0xc8, 0x2e, 0x00, 0x2e, 0x90, 0x32, 0x21, 0x2e, + 0x59, 0xf5, 0x10, 0x30, 0x21, 0x2e, 0x6a, 0xf5, 0x1a, 0x24, 0x22, 0x00, + 0x80, 0x2e, 0x3b, 0x00, 0xc8, 0x2e, 0x44, 0x47, 0x22, 0x00, 0x37, 0x00, + 0xa4, 0x00, 0xff, 0x0f, 0xd1, 0x00, 0x07, 0xad, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, 0x80, 0x2e, 0x00, 0xc1, + 0x80, 0x2e, 0x00, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x24, + 0xfc, 0xf5, 0x80, 0x30, 0x40, 0x42, 0x50, 0x50, 0x00, 0x30, 0x12, 0x24, + 0xeb, 0x00, 0x03, 0x30, 0x00, 0x2e, 0xc1, 0x86, 0x5a, 0x0e, 0xfb, 0x2f, + 0x21, 0x2e, 0xfc, 0xf5, 0x13, 0x24, 0x63, 0xf5, 0xe0, 0x3c, 0x48, 0x00, + 0x22, 0x30, 0xf7, 0x80, 0xc2, 0x42, 0xe1, 0x7f, 0x3a, 0x25, 0xfc, 0x86, + 0xf0, 0x7f, 0x41, 0x33, 0x98, 0x2e, 0xc2, 0xc4, 0xd6, 0x6f, 0xf1, 0x30, + 0xf1, 0x08, 0xc4, 0x6f, 0x11, 0x24, 0xff, 0x03, 0x12, 0x24, 0x00, 0xfc, + 0x61, 0x09, 0xa2, 0x08, 0x36, 0xbe, 0x2a, 0xb9, 0x13, 0x24, 0x38, 0x00, + 0x64, 0xbb, 0xd1, 0xbe, 0x94, 0x0a, 0x71, 0x08, 0xd5, 0x42, 0x21, 0xbd, + 0x91, 0xbc, 0xd2, 0x42, 0xc1, 0x42, 0x00, 0xb2, 0xfe, 0x82, 0x05, 0x2f, + 0x50, 0x30, 0x21, 0x2e, 0x21, 0xf2, 0x00, 0x2e, 0x00, 0x2e, 0xd0, 0x2e, + 0xf0, 0x6f, 0x02, 0x30, 0x02, 0x42, 0x20, 0x26, 0xe0, 0x6f, 0x02, 0x31, + 0x03, 0x40, 0x9a, 0x0a, 0x02, 0x42, 0xf0, 0x37, 0x05, 0x2e, 0x5e, 0xf7, + 0x10, 0x08, 0x12, 0x24, 0x1e, 0xf2, 0x80, 0x42, 0x83, 0x84, 0xf1, 0x7f, + 0x0a, 0x25, 0x13, 0x30, 0x83, 0x42, 0x3b, 0x82, 0xf0, 0x6f, 0x00, 0x2e, + 0x00, 0x2e, 0xd0, 0x2e, 0x12, 0x40, 0x52, 0x42, 0x00, 0x2e, 0x12, 0x40, + 0x52, 0x42, 0x3e, 0x84, 0x00, 0x40, 0x40, 0x42, 0x7e, 0x82, 0xe1, 0x7f, + 0xf2, 0x7f, 0x98, 0x2e, 0x6a, 0xd6, 0x21, 0x30, 0x23, 0x2e, 0x61, 0xf5, + 0xeb, 0x2c, 0xe1, 0x6f +}; +//328 bytes + +static struct Bmi270DrvData *Bmi270GetDrvData(void) +{ + return g_bmi270DrvData; +}; + +/// @brief basic register write function +/// @param data Sensor configuration data structre pointer +/// @param rega register address +/// @param buffer value to write +/// @param len write len +/// @return HDF_SUCCESS if success, failed any error +static int32_t GyroBmi270HalRegWrite(struct SensorCfgData *data, uint16_t rega, uint8_t* buffer, uint32_t len) +{ + int32_t rc = HDF_SUCCESS; + uint32_t idx = 0; + (void)memset_s(g_regw_buffer, sizeof(g_regw_buffer), 0, sizeof(g_regw_buffer)); + + g_regw_buffer[0] = (rega & 0xFF); + do { + g_regw_buffer[idx + 1] = buffer[idx]; + idx ++; + } while (idx < len); + + rc = WriteSensor(&data->busCfg, g_regw_buffer, (len + 1)); + OsalUDelay(BMI270_LP_MODE_WRITE_DELAY_IN_US); + + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] w reg:%d err", __func__, rega); + } + + return rc; +} + +/// @brief basic register read function +/// @param data Sensor configuration data structre pointer +/// @param rega register address to read +/// @param buffer read data buffer +/// @param len read len +/// @return HDF_SUCCESS if success, failed any error +static int32_t GyroBmi270HalRegRead(struct SensorCfgData *data, uint16_t rega, uint8_t* buffer, uint32_t len) +{ + int32_t rc = HDF_SUCCESS; + rc = ReadSensor(&data->busCfg, rega, buffer, len); + OsalUDelay(BMI270_NORMAL_MODE_WRITE_DELAY_IN_US); + + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] r reg:%d err", __func__, rega); + } + + return rc; +} + +static int32_t GyroReadBmi270RawData(struct SensorCfgData *data, struct GyroData *rawData, int64_t *timestamp) +{ + OsalTimespec time; + uint8_t status = 0; + uint8_t regv[GYRO_AXIS_BUTT] = {0}; + int32_t ret = HDF_SUCCESS; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + (void)memset_s(regv, sizeof(regv), 0, sizeof(regv)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + + ret = GyroBmi270HalRegRead(data, BMI270_GYRO_REGA_STATUS, &status, sizeof(uint8_t)); + /* any new data? */ + if (!(status & BMI270_GYRO_DATA_READY_MASK) || (ret != HDF_SUCCESS)) { + return HDF_FAILURE; + } + + ret = GyroBmi270HalRegRead(data, BMI270_GYRO_REGA_X_LSB_ADDR, regv, BMI270_GYR_DATA_FRAME_SIZE); + + rawData->x = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[GYRO_X_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[GYRO_X_AXIS_LSB]); + rawData->y = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[GYRO_Y_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[GYRO_Y_AXIS_LSB]); + rawData->z = (int16_t)(SENSOR_DATA_SHIFT_LEFT(regv[GYRO_Z_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + regv[GYRO_Z_AXIS_LSB]); + + return ret; +} + +static int32_t GyroReadBmi270Data(struct SensorCfgData *cfg) +{ + int32_t ret; + struct GyroData rawData = { 0, 0, 0 }; + static int32_t tmp[GYRO_AXIS_NUM]; + struct SensorReportEvent event; + + CHECK_NULL_PTR_RETURN_VALUE(cfg, HDF_ERR_INVALID_PARAM); + + ret = GyroReadBmi270RawData(cfg, &rawData, &event.timestamp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 read raw data failed", __func__); + return HDF_FAILURE; + } + + event.sensorId = SENSOR_TAG_GYROSCOPE; + event.option = 0; + event.mode = SENSOR_WORK_MODE_REALTIME; + + rawData.x = rawData.x * BMI270_GYRO_SENSITIVITY_2000DPS; + rawData.y = rawData.y * BMI270_GYRO_SENSITIVITY_2000DPS; + rawData.z = rawData.z * BMI270_GYRO_SENSITIVITY_2000DPS; + + tmp[GYRO_X_AXIS] = (rawData.x * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + tmp[GYRO_Y_AXIS] = (rawData.y * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + tmp[GYRO_Z_AXIS] = (rawData.z * SENSOR_CONVERT_UNIT) / SENSOR_CONVERT_UNIT; + + ret = SensorRawDataToRemapData(cfg->direction, tmp, sizeof(tmp) / sizeof(tmp[0])); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 convert raw data failed", __func__); + return HDF_FAILURE; + } + + event.dataLen = sizeof(tmp); + event.data = (uint8_t *)&tmp; + ret = ReportSensorEvent(&event); + + return ret; +} + +// success +static int32_t Bmi270IMUSwReset(struct SensorCfgData* data) +{ + uint8_t regv = BMI26X_REGV_CMD_SOFT_RESET; + int32_t rc = GyroBmi270HalRegWrite(data, BMI26X_REGA_USR_CMD, ®v, BMI270_ONE_BYTE); + // delay 5ms after reset + OsalMDelay(BMI270_RESET_DELAY_IN_MS); + + return rc; +} + +static bool Bmi270HalIMUInited(struct SensorCfgData *data) +{ + bool rc = false; + uint8_t regv = 0; + rc = GyroBmi270HalRegRead(data, BMI270_REGA_INTERNAL_STATUS, ®v, BMI270_ONE_BYTE); + if (BST_GET_VAL_BIT(regv, 0)) { + HDF_LOGI("[BMI270] %s, IMU inited", __LINE__); + rc = true; + } + + return rc; +} + +static int32_t Bmi270CfgGyroPwr(struct SensorCfgData *data, bool en) +{ + uint8_t regv = 0; + int32_t rc = HDF_SUCCESS; + rc = GyroBmi270HalRegRead(data, BMI270_REGA_PWR_CTRL, ®v, BMI270_ONE_BYTE); + + if (en) { + regv = BST_SET_VAL_BIT(regv, BMI270_GYR_POWER_BIT_POS_IN_PWR_CTRL_REG); + } else { + regv = BST_CLR_VAL_BIT(regv, BMI270_GYR_POWER_BIT_POS_IN_PWR_CTRL_REG); + } + + rc = GyroBmi270HalRegWrite(data, BMI270_REGA_PWR_CTRL, ®v, BMI270_ONE_BYTE); + + return rc; +} + +// @load configuration +static int32_t Bmi270LoadCfg(struct SensorCfgData *data, uint8_t* cfg_data_buffer, + uint32_t cfg_size, uint32_t in_burst_write_size) +{ + int32_t rc = HDF_SUCCESS; + uint8_t regv = 0; + /* Variable to update the configuration file index */ + uint16_t index = 0; + /* Array to store address */ + uint8_t addr_array[2] = {0}; + uint32_t size_bw = in_burst_write_size; //burst write size in byte + + /* Disable loading of the configuration */ + rc = GyroBmi270HalRegWrite(data, BMI26X_REGA_USR_TITAN_CTRL, ®v, BMI270_ONE_BYTE); + + for (index = 0; index < cfg_size; index += size_bw) { + //1. len + if (index + in_burst_write_size > cfg_size) { + size_bw = cfg_size - index; + } + + // index low in word + addr_array[0] = (uint8_t)((index / 2) & 0x0F); + // index high in word + addr_array[1] = (uint8_t)((index / 2) >> 4); + rc = GyroBmi270HalRegWrite(data, BMI26X_REGA_USR_CONF_STREAM_IDX_LSB, addr_array, BMI270_TWO_BYTE); + + //2. data + rc = GyroBmi270HalRegWrite(data, BMI26X_REGA_USR_CONF_STREAM_IN, + cfg_data_buffer + index, size_bw); + } + + return rc; +} + +static int32_t Bmi270HalLoadCfg(struct SensorCfgData *data) +{ + int32_t rc = HDF_SUCCESS; + uint8_t regv = 0; + uint8_t try_num_to_check_cfg = 0; + bool cfg_is_avaiblabe = Bmi270HalIMUInited(data); + if (cfg_is_avaiblabe) { + return HDF_SUCCESS; + } + + rc = Bmi270IMUSwReset(data); + if (rc != HDF_SUCCESS) { + return rc; + } + + //disable advance power saving + rc = GyroBmi270HalRegWrite(data, BMI270_REGA_PWR_CFG, ®v, BMI270_ONE_BYTE); + + // load configuration now + rc = Bmi270LoadCfg(data, bmi270_cfg_buffer, + HDF_ARRAY_SIZE(bmi270_cfg_buffer), + HDF_ARRAY_SIZE(bmi270_cfg_buffer)); + + regv = 0x01; + rc = GyroBmi270HalRegWrite(data, BMI26X_REGA_USR_TITAN_CTRL, ®v, BMI270_ONE_BYTE); + + cfg_is_avaiblabe = false; + rc = HDF_DEV_ERR_DEV_INIT_FAIL; + do { + OsalMDelay(BMI270_LOAD_RAM_PATCH_DELAY_IN_MS); //10ms + cfg_is_avaiblabe = Bmi270HalIMUInited(data); + try_num_to_check_cfg ++; + if (cfg_is_avaiblabe) { + rc = HDF_SUCCESS; + break; + } + } while ((try_num_to_check_cfg < BMI26X_CHECK_CONFIGURE_STATUS_TIMES) && + (!cfg_is_avaiblabe)); + + return rc; +} + +static int32_t Bmi270GetWhoAmI(struct SensorCfgData *data) +{ + uint8_t regv = 0; + int32_t rc = HDF_SUCCESS; + + rc = GyroBmi270HalRegRead(data, 0x00, ®v, BMI270_ONE_BYTE); + if (rc != HDF_SUCCESS) { + HDF_LOGE("%s: [BMI270] WARN!!, NO Sensor", __func__); + return HDF_FAILURE; + } + if (regv != BMI26X_REGV_WHOAMI) { + rc = HDF_DEV_ERR_NO_DEVICE; + } + + return rc; +} + + +static int32_t InitBmi270(struct SensorCfgData *data) +{ + int32_t ret = HDF_SUCCESS; + uint8_t regv = 0x00; + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI270 sensor init config failed", __func__); + return HDF_FAILURE; + } + + ret = Bmi270CfgGyroPwr(data, true); + //defualt odr:200hz + // range:+/- 2000dps, 16.4LSB/dps + regv = 0; + ret = GyroBmi270HalRegWrite(data, BMI26X_REGA_GYRO_RANGE, ®v, BMI270_ONE_BYTE); + + return ret; +} + +static int32_t DispatchBMI270(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +static int32_t GyroBmi270BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Bmi270 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBMI270; + drvData->device = device; + device->service = &drvData->ioService; + g_bmi270DrvData = drvData; + + return HDF_SUCCESS; +} + +static int32_t GyroBmi270InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct GyroOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->sensorCfg = GyroCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating gyrocfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = GyroReadBmi270Data; + ret = GyroRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register BMI270 gyro failed", __func__); + return HDF_FAILURE; + } + + // check whoami + ret = Bmi270GetWhoAmI(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + return ret; + } + + do { + ret = Bmi270HalLoadCfg(drvData->sensorCfg); + } while (0); + + //init hw + ret = InitBmi270(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BMI270 gyro failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static void GyroBmi270ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Bmi270DrvData *drvData = (struct Bmi270DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + GyroReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_gyroBmi270DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_GYRO_BMI270", + .Bind = GyroBmi270BindDriver, + .Init = GyroBmi270InitDriver, + .Release = GyroBmi270ReleaseDriver, +}; + +HDF_INIT(g_gyroBmi270DevEntry); diff --git a/sensor/chipset/gyro/gyro_bmi270.h b/sensor/chipset/gyro/gyro_bmi270.h new file mode 100644 index 0000000000..593fe47618 --- /dev/null +++ b/sensor/chipset/gyro/gyro_bmi270.h @@ -0,0 +1,97 @@ +/** +* Copyright (c) 2024 Bosch Sensortec GmbH. All rights reserved. +* +* gyro_bmi270.h as part of the * /chipsets subdirectory +* is dual licensed: you can use it either under the terms of +* the GPL, or the BSD license, at your option. +* See the LICENSE file in the root of this repository for complete details. +*/ + +#ifndef GYRO_BMI270_H +#define GYRO_BMI270_H + +#include "sensor_gyro_driver.h" +#include "sensor_config_parser.h" + +#define BMI270_GYR_DATA_FRAME_SIZE 6 +#define BMI270_ONE_BYTE sizeof(uint8_t) +#define BMI270_TWO_BYTE sizeof(uint16_t) + +// bus operation delay +#define BMI270_NORMAL_MODE_WRITE_DELAY_IN_US 4 +#define BMI270_LP_MODE_WRITE_DELAY_IN_US 460 + +// feature operation delay +#define BMI270_RESET_DELAY_IN_MS 5 +#define BMI270_LOAD_RAM_PATCH_DELAY_IN_MS 10 + +// bit definition +#define BMI270_GYR_POWER_BIT_POS_IN_PWR_CTRL_REG 1 + + +#define BST_GET_VAL_BIT(val, bit) (((val)>>(bit)) & 0x01) +#define BST_SET_VAL_BIT(val, bit) ((val) | (1 << (bit))) +#define BST_CLR_VAL_BIT(val, bit) ((val) & (~(1 << (bit)))) + +#define BMI270_GYRO_REGA_STATUS 0x03 +/* GYRO DATA REGISTERS ADDR */ +#define BMI270_GYRO_REGA_X_LSB_ADDR 0X12 +#define BMI270_GYRO_REGA_X_MSB_ADDR 0X13 +#define BMI270_GYRO_REGA_Y_LSB_ADDR 0X14 +#define BMI270_GYRO_REGA_Y_MSB_ADDR 0X15 +#define BMI270_GYRO_REGA_Z_LSB_ADDR 0X16 +#define BMI270_GYRO_REGA_Z_MSB_ADDR 0X17 +#define BMI270_STATUS_ADDR 0x1B + +/* GYRO ODR */ +#define BMI270_GYRO_ODR_RESERVED 0x00 +#define BMI270_GYRO_ODR_25HZ 0x06 +#define BMI270_GYRO_ODR_50HZ 0x07 +#define BMI270_GYRO_ODR_100HZ 0x08 +#define BMI270_GYRO_ODR_200HZ 0x09 +#define BMI270_GYRO_ODR_400HZ 0x0A +#define BMI270_GYRO_ODR_800HZ 0x0B +#define BMI270_GYRO_ODR_1600HZ 0x0C +#define BMI270_GYRO_ODR_3200HZ 0x0D + +/* default HZ */ +#define BMI270_GYRO_DEFAULT_ODR_100HZ 100 +#define BMI270_GYRO_DEFAULT_ODR_25HZ 25 + +/* GYRO RANGE */ +#define BMI270_GYRO_RANGE_2000DPS 0X00 +#define BMI270_GYRO_RANGE_1000DPS 0X01 +#define BMI270_GYRO_RANGE_500DPS 0X02 +#define BMI270_GYRO_RANGE_250DPS 0X03 +#define BMI270_GYRO_RANGE_125DPS 0X04 + +/* GYRO sensitivity */ +#define BMI270_GYRO_SENSITIVITY_2000DPS 61 + +/* GYRO DATA READY */ +#define BMI270_GYRO_DATA_READY_MASK 0x40 +#define BMI26X_REGV_WHOAMI 0x24 +#define BMI270_REGA_INTERNAL_STATUS 0x21 + +#define BMI26X_REGA_GYRO_ODR 0x42 +#define BMI26X_REGA_GYRO_RANGE 0x43 + +#define BMI26X_REGA_USR_TITAN_CTRL 0x59 +#define BMI26X_REGA_USR_CONF_STREAM_IDX_LSB 0x5b +#define BMI26X_REGA_USR_CONF_STREAM_IN 0x5e + +#define BMI270_REGA_PWR_CFG 0x7C +#define BMI270_REGA_PWR_CTRL 0x7D +#define BMI26X_REGA_USR_CMD 0x7E + +#define BMI26X_CHECK_CONFIGURE_STATUS_TIMES 15 + +#define BMI26X_REGV_CMD_SOFT_RESET 0xB6 + +struct Bmi270DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + +#endif /* GYRO_BMI270_H */ -- Gitee From 311d8062d419d490d280887d3093f5b55c357b53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Tue, 30 Jul 2024 11:28:03 +0000 Subject: [PATCH 0008/1485] =?UTF-8?q?USB=20DDK=E4=BB=A3=E7=A0=81=E6=95=B4?= =?UTF-8?q?=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/device/src/adapter_if_liteos.c | 5 +++++ usb/ddk/host/src/linux_adapter.c | 4 ++++ usb/ddk/host/src/liteos_adapter.c | 2 ++ usb/ddk/host/src/usb_io_manage.c | 1 + 4 files changed, 12 insertions(+) diff --git a/usb/ddk/device/src/adapter_if_liteos.c b/usb/ddk/device/src/adapter_if_liteos.c index 8a7d3f3614..007ded01da 100644 --- a/usb/ddk/device/src/adapter_if_liteos.c +++ b/usb/ddk/device/src/adapter_if_liteos.c @@ -427,27 +427,32 @@ static int32_t UsbFnAdapterCreatPipes(int32_t ep0, const struct UsbFnFunction *f ret = memcpy_s(whereDec, header.length, &header, sizeof(struct UsbFunctionfsDescsHeadV2)); if (ret != EOK) { + UsbFnMemFree(dec); return HDF_FAILURE; } whereDec += sizeof(struct UsbFunctionfsDescsHeadV2); ret = CopyCount(&whereDec, fsCount, hsCount, ssCount); if (ret != EOK) { + UsbFnMemFree(dec); return HDF_FAILURE; } ret = WriteFuncDescriptors(&whereDec, func->fsDescriptors); if (ret != EOK) { + UsbFnMemFree(dec); return HDF_FAILURE; } ret = WriteFuncDescriptors(&whereDec, func->hsDescriptors); if (ret != EOK) { + UsbFnMemFree(dec); return HDF_FAILURE; } ret = WriteFuncDescriptors(&whereDec, func->ssDescriptors); if (ret != EOK) { + UsbFnMemFree(dec); return HDF_FAILURE; } diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 55a09734de..9c6496a4f3 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -459,6 +459,7 @@ static int32_t OsSubmitControlRequest(struct UsbHostRequest *request) } return HDF_ERR_IO; } + RawUsbMemFree(urb); return HDF_SUCCESS; } @@ -1301,6 +1302,9 @@ static struct UsbHostRequest *AdapterAllocRequest(const struct UsbDeviceHandle * request->bulkUrb = RawUsbMemCalloc(sizeof(struct UsbAdapterUrb)); if (request->bulkUrb == NULL) { HDF_LOGE("%{public}s RawUsbMemAlloc fail", __func__); +#ifdef USB_EVENT_NOTIFY_LINUX_NATIVE_MODE + RawUsbMemFree(memBuf); +#endif return NULL; } request->urbs = request->bulkUrb; diff --git a/usb/ddk/host/src/liteos_adapter.c b/usb/ddk/host/src/liteos_adapter.c index 7dc0b338bb..be6f2923e9 100644 --- a/usb/ddk/host/src/liteos_adapter.c +++ b/usb/ddk/host/src/liteos_adapter.c @@ -647,6 +647,7 @@ static int32_t OsSubmitBulkRequestHandle( request->reqStatus = USB_REQUEST_ERROR; } OsDiscardUrbs(request, 0, i); + RawUsbMemFree(pas); OsalMutexUnlock(&request->lock); return HDF_SUCCESS; } @@ -1134,6 +1135,7 @@ static struct UsbDeviceHandle *AdapterOpenDevice(struct UsbSession *session, uin ret = OsInitDevice(dev, busNum, usbAddr); if (ret) { DPRINTFN(0, "%s: OsInitDevice failed ret=%d\n", __func__, ret); + RawUsbMemFree(dev->privateData); RawUsbMemFree(dev); goto ERR; } diff --git a/usb/ddk/host/src/usb_io_manage.c b/usb/ddk/host/src/usb_io_manage.c index 1d2031b958..cb992c8fd1 100644 --- a/usb/ddk/host/src/usb_io_manage.c +++ b/usb/ddk/host/src/usb_io_manage.c @@ -88,6 +88,7 @@ static int32_t IoSendProcess(const void *interfacePoolArg) break; } + RawUsbMemFree(submitRequest->urbs); if (i >= USB_IO_SUBMIT_RETRY_TIME_CNT) { HDF_LOGE("%{public}s:%{public}d submit request failed", __func__, __LINE__); submitRequest->status = USB_REQUEST_ERROR; -- Gitee From 2d92d201eaa05963b6829419f0d8b3388ca7804a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 30 Jul 2024 23:12:41 +0800 Subject: [PATCH 0009/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../tools/get_mem_excel/get_mem_excel.py | 174 ++++++++++++++++++ .../sample/tools/get_mem_excel/pid_list.txt | 3 + 2 files changed, 177 insertions(+) create mode 100644 audio/test/sample/tools/get_mem_excel/get_mem_excel.py create mode 100644 audio/test/sample/tools/get_mem_excel/pid_list.txt diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py new file mode 100644 index 0000000000..cfaaebc4f1 --- /dev/null +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -0,0 +1,174 @@ +import os +import sys +import subprocess +import sqlite3 +import threading +import time +import re +import shutil +import uuid +import random +import json +import sqlite3 +import datetime +import pandas as pd +import inspect + +# The following programs are packaged as exe commands +# pyinstaller --onefile get_mem_excel.py + +now_time = "null" +now_version = "null" +hidumper_num = 0 +pid_list = [] +mem_file_name = "" +mem_smaps_file_name = "" + + +# Run a cmd command +def run_cmd(cmd): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: {cmd}") + output = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, + check=True).stdout + print(f"{__func__}: result:{str(output)}") + return output + + +# Wait for the HDC to connect to the device +def wait_for_device(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + run_cmd("hdc wait-for-device") + + +# Gets the current time, which is used as the file name part of the scraped data +def update_now_time(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global now_time + now_time = str(datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) + + +# Obtain the current device version number, which is used as the file name part of the scraped data +def update_now_version(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global now_version + now_version = str(run_cmd("hdc shell param get const.product.software.version")).replace("\n", "").replace(" ", "") + + +# Obtain the list of process names to be captured from the pid_list.txt, if not configured, there is a default value +def get_pid_list(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global pid_list + list_file_path = "pid_list.txt" + if os.path.exists(list_file_path): + list_file = open(list_file_path, 'r') + for line in list_file.readlines(): + pid_list.append(line.replace('\n', '')) + else: + print(f"{__func__}: pid_list.txt not exists, get mem for sensor_host,vibrator_host,audio_host,allocator_host") + pid_list.append('sensor_host') + # pid_list.append('vibrator_host') + # pid_list.append('audio_host') + # pid_list.append('allocator_host') + + +# Grab simple memory information for a process +def get_mem(p_name): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in, p_name {p_name}") + global mem_file_name + mem_file_name = "result-mem" + now_version + p_name + now_time + ".txt" + cmd = "hdc shell \"hidumper --mem `pidof " + p_name + "`\" > " + mem_file_name + run_cmd(cmd) + + +# Fetch detailed memory information for a process +def get_mem_smaps(p_name): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in, p_name {p_name}") + global mem_smaps_file_name + mem_smaps_file_name = "result-mem_smaps" + now_version + p_name + now_time + ".txt" + cmd = "hdc shell \"hidumper --mem-smaps `pidof " + p_name + "` -v\" > " + mem_smaps_file_name + run_cmd(cmd) + + +# Parse Excel sheets based on detailed memory information for a process +def get_mem_smaps_excel(p_name): + global hidumper_num + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + mem_file = open(mem_smaps_file_name, "r") + datas = mem_file.readlines() + result_map = {} + result_list = [] + mem_index = -1 + for line in datas: + fields = line.split() + if len(fields) > 2 and 'Pss' in fields: + hidumper_num = len(fields) + mem_index = fields.index("Pss") + continue + if len(fields) == 10: + print(fields) + mem_data = int(fields[mem_index]) + result_map["总和"] = mem_data + continue + if len(fields) != hidumper_num or hidumper_num == 0 or mem_index == -1: + continue + mem_data = int(fields[mem_index]) + mem_name = fields[hidumper_num - 1] + matchs = [ + r'\[anon:guard:\d*\]', + r'\[anon:stack:\d*\]', + r'\[anon:signal_stack:\d*\]' + ] + for match in matchs: + if re.findall(match, mem_name): + mem_name = match + if mem_name not in result_map: + result_map[mem_name] = 0 + result_map[mem_name] += mem_data + for key in result_map: + result_list.append([key, result_map[key]]) + headers = ['作用域名', '内存值'] + df = pd.DataFrame(result_list, columns=headers) + output_file = "result-mem-" + now_version + p_name + now_time + ".xlsx" + df.to_excel(output_file, index=False) + + +# Scrape a process's in-memory data +def get_data(p_name): + get_mem(p_name) + get_mem_smaps(p_name) + get_mem_smaps_excel(p_name) + + +# Scrapes the memory data of all configured processes +def get_all_process_data(): + for p_name in pid_list: + get_data(p_name) + + +# Perform a one-time crawl of memory data for all processes configured +def get_data_once(): + wait_for_device() + update_now_time() + update_now_version() + get_all_process_data() + + +# Perform num fetch of the memory data of all processes configured at daily intervals +def get_data_more(num, daily): + for i in range(num): + get_data_once() + time.sleep(daily) + + +if __name__ == "__main__": + get_pid_list() + get_data_more(1, 10) + pass diff --git a/audio/test/sample/tools/get_mem_excel/pid_list.txt b/audio/test/sample/tools/get_mem_excel/pid_list.txt new file mode 100644 index 0000000000..964ba0acd5 --- /dev/null +++ b/audio/test/sample/tools/get_mem_excel/pid_list.txt @@ -0,0 +1,3 @@ +sensor_host +audio_host +composer_host \ No newline at end of file -- Gitee From ee43839d92f07be74d44a0a7cadef20bcdadab7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 30 Jul 2024 23:13:50 +0800 Subject: [PATCH 0010/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- audio/test/sample/tools/get_mem_excel/get_mem_excel.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py index cfaaebc4f1..cd0b4c667a 100644 --- a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -71,9 +71,9 @@ def get_pid_list(): else: print(f"{__func__}: pid_list.txt not exists, get mem for sensor_host,vibrator_host,audio_host,allocator_host") pid_list.append('sensor_host') - # pid_list.append('vibrator_host') - # pid_list.append('audio_host') - # pid_list.append('allocator_host') + pid_list.append('vibrator_host') + pid_list.append('audio_host') + pid_list.append('allocator_host') # Grab simple memory information for a process -- Gitee From e239ac2e27dfae72efb07b14de3b5aa0c26234c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 30 Jul 2024 23:15:46 +0800 Subject: [PATCH 0011/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- audio/test/sample/tools/get_mem_excel/get_mem_excel.py | 1 - 1 file changed, 1 deletion(-) diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py index cd0b4c667a..49793e9cea 100644 --- a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -113,7 +113,6 @@ def get_mem_smaps_excel(p_name): mem_index = fields.index("Pss") continue if len(fields) == 10: - print(fields) mem_data = int(fields[mem_index]) result_map["总和"] = mem_data continue -- Gitee From 7649fec1a4bfa3d721d468175ac5a15d117a0a1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 30 Jul 2024 16:00:41 +0000 Subject: [PATCH 0012/1485] update audio/test/sample/tools/get_mem_excel/get_mem_excel.py. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../sample/tools/get_mem_excel/get_mem_excel.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py index 49793e9cea..ab2642f748 100644 --- a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -1,3 +1,18 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + import os import sys import subprocess -- Gitee From f0ac648c1de183d636dfb5090c7caf11ac961669 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 31 Jul 2024 09:27:53 +0800 Subject: [PATCH 0013/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../tools/get_mem_excel/get_mem_excel.py | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py index ab2642f748..5b013e3ed2 100644 --- a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -1,17 +1,17 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ +# +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# import os import sys -- Gitee From d335bd2eb57e900f84e81541928e666892a1e368 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 31 Jul 2024 09:36:08 +0800 Subject: [PATCH 0014/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- audio/test/sample/tools/get_mem_excel/get_mem_excel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py index 5b013e3ed2..324d337117 100644 --- a/audio/test/sample/tools/get_mem_excel/get_mem_excel.py +++ b/audio/test/sample/tools/get_mem_excel/get_mem_excel.py @@ -44,7 +44,7 @@ mem_smaps_file_name = "" def run_cmd(cmd): __func__ = inspect.currentframe().f_code.co_name print(f"{__func__}: {cmd}") - output = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, + output = subprocess.run(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, check=True).stdout print(f"{__func__}: result:{str(output)}") return output -- Gitee From 81d328c7d472671ffd3730ba2ba66a950446bbef Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Wed, 31 Jul 2024 15:18:57 +0800 Subject: [PATCH 0015/1485] commit msg Signed-off-by: xuxuehai --- .../hdi_service/primary_impl/src/audio_render.c | 3 +-- .../primary_impl/vdi_src/audio_common_vdi.c | 2 ++ .../primary_impl/vdi_src/audio_manager_vdi.c | 4 ++++ .../alsa_adapter/src/alsa_snd_capture.c | 15 ++++++--------- .../alsa_adapter/src/alsa_snd_render.c | 16 ++++++---------- .../alsa_adapter/src/alsa_soundcard.c | 15 ++++++--------- 6 files changed, 25 insertions(+), 30 deletions(-) diff --git a/audio/hdi_service/primary_impl/src/audio_render.c b/audio/hdi_service/primary_impl/src/audio_render.c index fc299e850b..2f78eeaaa1 100644 --- a/audio/hdi_service/primary_impl/src/audio_render.c +++ b/audio/hdi_service/primary_impl/src/audio_render.c @@ -835,13 +835,12 @@ int32_t AudioRenderRenderFrame( struct IAudioRender *render, const int8_t *frame, uint32_t frameLen, uint64_t *replyBytes) { struct AudioHwRender *hwRender = (struct AudioHwRender *)render; - pthread_mutex_lock(&hwRender->renderParam.frameRenderMode.mutex); if (hwRender == NULL || frame == NULL || replyBytes == NULL || hwRender->renderParam.frameRenderMode.buffer == NULL) { - pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); AUDIO_FUNC_LOGE("Render Frame Paras is NULL!"); return AUDIO_ERR_INVALID_PARAM; } + pthread_mutex_lock(&hwRender->renderParam.frameRenderMode.mutex); if (frameLen > FRAME_DATA) { pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); AUDIO_FUNC_LOGE("Out of FRAME_DATA size!"); diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_common_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_common_vdi.c index 0d97f0a15d..920d6ee382 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_common_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_common_vdi.c @@ -178,6 +178,8 @@ static int32_t AudioSubPortsToSubPortsVdi(const struct AudioSubPortCapabilityVdi subPortsTmp[i].mask = (enum AudioPortPassthroughMode)vdiSubPorts[i].mask; subPortsTmp[i].desc = strdup(vdiSubPorts[i].desc); if (subPortsTmp[i].desc == NULL) { + *subPorts = subPortsTmp; + *subPortsLen = size; AUDIO_FUNC_LOGE("strdup fail, vdiSubPorts[%{public}d].desc = %{public}s", i, vdiSubPorts[i].desc); return HDF_FAILURE; } diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index 9ef3d80708..dccbfc6a85 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -127,6 +127,8 @@ static int32_t AudioManagerPortToVdiPort(const struct AudioAdapterDescriptor *de for (uint32_t i = 0; i < desc->portsLen; i++) { vdiPorts[i].portName = strdup(desc->ports[i].portName); if (vdiPorts[i].portName == NULL) { + vdiDesc->ports = vdiPorts; + vdiDesc->portsLen = desc->portsLen; AUDIO_FUNC_LOGE("strdup fail, desc->ports[%{public}d].portName = %{public}s", i, desc->ports[i].portName); return HDF_FAILURE; } @@ -157,6 +159,8 @@ static int32_t AudioManagerVdiPortToPort(struct AudioAdapterDescriptorVdi *vdiDe for (uint32_t i = 0; i < vdiDesc->portsLen; i++) { ports[i].portName = strdup(vdiDesc->ports[i].portName); if (ports[i].portName == NULL) { + desc->ports = ports; + desc->portsLen = vdiDesc->portsLen; AUDIO_FUNC_LOGE("strdup fail, vdiDesc->ports[%{public}d].portName = %{public}s", i, vdiDesc->ports[i].portName); return HDF_FAILURE; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index 99a8ff8bd3..5a78cfe5da 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -45,10 +45,8 @@ CapturePriData CaptureGetPriData(struct AlsaCapture *captureIns) static int32_t CaptureFreeMemory(void) { - int32_t i; - if (g_alsaCaptureList != NULL) { - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { if (g_alsaCaptureList[i].soundCard.cardStatus != 0) { AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); return HDF_ERR_DEVICE_BUSY; @@ -242,7 +240,7 @@ static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t acces } cardIns->canPause = snd_pcm_hw_params_can_pause(hwParams); - AUDIO_FUNC_LOGI("hardware driver %{public}s support pause",cardIns->canPause ? "is" : "is not"); + AUDIO_FUNC_LOGI("hardware driver %{public}s support pause", cardIns->canPause ? "is" : "is not"); return HDF_SUCCESS; } @@ -547,8 +545,6 @@ static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle) static int32_t CapturePcmReadi(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize) { - int32_t ret; - long frames; int32_t tryNum = AUDIO_ALSALIB_RETYR; CHECK_NULL_PTR_RETURN_DEFAULT(pcm); CHECK_NULL_PTR_RETURN_DEFAULT(frameCnt); @@ -559,8 +555,9 @@ static int32_t CapturePcmReadi(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf } do { + int32_t ret; /* Read interleaved frames to a PCM. */ - frames = snd_pcm_readi(pcm, dataBuf, bufSize); + long frames = snd_pcm_readi(pcm, dataBuf, bufSize); if (frames > 0) { *frameCnt = (uint64_t)frames; return HDF_SUCCESS; @@ -674,11 +671,10 @@ static int32_t CaptureCloseImpl(struct AlsaCapture *captureIns) static int32_t CaptureCheckMmapMode(struct AlsaSoundCard *cardIns) { - int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); if (!cardIns->mmapFlag) { - ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + int32_t ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return ret; @@ -917,6 +913,7 @@ static void RegisterCaptureImpl(struct AlsaCapture *captureIns) { if (captureIns == NULL) { AUDIO_FUNC_LOGE("captureIns is NULL!"); + return; } captureIns->Init = CaptureInitImpl; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index 2f85df3185..d952038db4 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -64,10 +64,8 @@ static int32_t CreateRenderIns(void) static int32_t RenderFreeMemory(void) { - int32_t i; - if (g_alsaRenderList != NULL) { - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { if (g_alsaRenderList[i].soundCard.cardStatus != 0) { AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!"); return HDF_ERR_DEVICE_BUSY; @@ -214,7 +212,6 @@ static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t acces static int32_t SetSWParams(struct AlsaSoundCard *cardIns) { int32_t ret; - int32_t val = 1; /* val 0 = disable period event, 1 = enable period event */ snd_pcm_sw_params_t *swParams = NULL; snd_pcm_t *handle = cardIns->pcmHandle; struct AlsaRender *renderIns = (struct AlsaRender *)cardIns; @@ -251,6 +248,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) /* enable period events when requested */ if (renderIns->periodEvent) { + int32_t val = 1; /* val 0 = disable period event, 1 = enable period event */ ret = snd_pcm_sw_params_set_period_event(handle, swParams, val); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret)); @@ -568,7 +566,6 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han const struct AudioPcmHwParams *hwParams) { int32_t ret, offset; - long frames; char *dataBuf; size_t sbufFrameSize; snd_pcm_state_t state; @@ -588,7 +585,7 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han dataBuf = handleData->frameRenderMode.buffer; offset = hwParams->bitsPerFrame / BIT_COUNT_OF_BYTE; while (sbufFrameSize > 0) { - frames = snd_pcm_writei(pcm, dataBuf, sbufFrameSize); + long frames = snd_pcm_writei(pcm, dataBuf, sbufFrameSize); if (frames > 0) { sbufFrameSize -= frames; dataBuf += frames * offset; @@ -627,7 +624,6 @@ static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct Audi uint32_t lastBuffSize; uint32_t loopTimes; uint32_t looper = 0; - uint32_t copyLen; int32_t count = 0; struct AudioMmapBufferDescriptor *mmapBufDesc = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); @@ -650,7 +646,7 @@ static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct Audi lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); while (looper < loopTimes) { - copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; + uint32_t copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); ret = snd_pcm_mmap_writei( cardIns->pcmHandle, (char *)mmapBufDesc->memoryAddress + mmapBufDesc->offset, frames); @@ -860,12 +856,11 @@ static int32_t RenderSetMuteImpl(struct AlsaRender *renderIns, bool muteFlag) static int32_t RenderSetPauseStateImpl(struct AlsaRender *renderIns, bool pauseFlag) { - int32_t ret; int enable = pauseFlag ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; if (cardIns->canPause) { - ret = snd_pcm_pause(cardIns->pcmHandle, enable); + int32_t ret = snd_pcm_pause(cardIns->pcmHandle, enable); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_pause failed!"); return HDF_FAILURE; @@ -898,6 +893,7 @@ static void RegisterRenderImpl(struct AlsaRender *renderIns) { if (renderIns == NULL) { AUDIO_FUNC_LOGE("renderIns is NULL!"); + return; } renderIns->Init = RenderInitImpl; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index dab1bdb308..947166c4d5 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -228,7 +228,7 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i static int32_t CfgParseAdapterItems(cJSON *adapterObj) { - int32_t ret, adapterNum; + int32_t adapterNum; cJSON *adapterItems = NULL; adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); @@ -253,7 +253,7 @@ static int32_t CfgParseAdapterItems(cJSON *adapterObj) AUDIO_FUNC_LOGE("Get adapter item from array failed!"); } - ret = CfgSaveAdapterStruct(adapter, &info); + int32_t ret = CfgSaveAdapterStruct(adapter, &info); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("CfgSaveAdapterStruct failed!"); return HDF_FAILURE; @@ -330,7 +330,6 @@ static struct AlsaDevInfo *DevGetInfoByPcmInfoId(const char * name) static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, int card, const char *deviceName) { - int32_t ret; int pcmDev = -1; snd_ctl_card_info_t *info = NULL; snd_pcm_info_t *pcminfo = NULL; @@ -349,7 +348,7 @@ static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, in snd_pcm_info_set_device(pcminfo, pcmDev); snd_pcm_info_set_subdevice(pcminfo, 0); snd_pcm_info_set_stream(pcminfo, stream); - ret = snd_ctl_pcm_info(handle, pcminfo); + int32_t ret = snd_ctl_pcm_info(handle, pcminfo); if (ret < 0) { if (ret != -ENOENT) { AUDIO_FUNC_LOGE("control digital audio info (%{public}d)", pcmDev); @@ -644,7 +643,6 @@ snd_pcm_state_t SndGetRunState(struct AlsaSoundCard * cardIns) void SndCloseHandle(struct AlsaSoundCard *cardIns) { - int32_t ret; if (cardIns == NULL) { AUDIO_FUNC_LOGE("cardIns is NULL"); return; @@ -653,6 +651,7 @@ void SndCloseHandle(struct AlsaSoundCard *cardIns) cardIns->cardStatus -= 1; } if (cardIns->cardStatus == 0) { + int32_t ret; if (cardIns->pcmHandle != NULL) { ret = snd_pcm_close(cardIns->pcmHandle); if (ret < 0) { @@ -1202,7 +1201,6 @@ int32_t SndElementWriteSwitch( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on) { int ret; - int value; snd_ctl_t *alsaHandle = NULL; snd_ctl_elem_id_t *elem_id; snd_ctl_elem_info_t *elem_info; @@ -1235,7 +1233,7 @@ int32_t SndElementWriteSwitch( snd_ctl_elem_value_set_id(elem_value, elem_id); type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_BOOLEAN) { - value = on ? 1 : 0; + int value = on ? 1 : 0; snd_ctl_elem_value_set_boolean(elem_value, 0, value); } else { AUDIO_FUNC_LOGE("Element value is not boolean type!\n"); @@ -1301,11 +1299,10 @@ int32_t SndElementWrite( int32_t SndElementGroupWrite( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement* elemGroup, int32_t groupSize) { - int err; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); for (int i = 0; i < groupSize; ++i) { - err = SndElementWrite(cardIns, &elemGroup[i]); + int err = SndElementWrite(cardIns, &elemGroup[i]); if (err < 0) { AUDIO_FUNC_LOGE("Cant't set element %{public}s", elemGroup[i].name); } -- Gitee From d40df6e2727e6b655b0cfe998a0367008d0b98e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 31 Jul 2024 16:27:43 +0800 Subject: [PATCH 0016/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../tools/get_trace_loop/get_trace_loop.py | 127 ++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 audio/test/sample/tools/get_trace_loop/get_trace_loop.py diff --git a/audio/test/sample/tools/get_trace_loop/get_trace_loop.py b/audio/test/sample/tools/get_trace_loop/get_trace_loop.py new file mode 100644 index 0000000000..2b6874f547 --- /dev/null +++ b/audio/test/sample/tools/get_trace_loop/get_trace_loop.py @@ -0,0 +1,127 @@ +# +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import os +import sys +import subprocess +import sqlite3 +import threading +import time +import re +import shutil +import uuid +import random +import json +import sqlite3 +import datetime +import pandas as pd +import inspect + +# The following programs are packaged as exe commands +# pyinstaller --onefile get_trace_loop.py + +trace_duration = 30 + +now_time = "null" +now_version = "null" +need_reboot = False +target_p_name = "sensor_host" +trace_file_name = "" +p_name_id = "" + + +# Run a cmd command +def run_cmd(cmd): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: {cmd}") + output = subprocess.run(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, + check=True).stdout + print(f"{__func__}: result:{str(output)}") + return output + + +# Wait for the HDC to connect to the device +def wait_for_device(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + run_cmd("hdc wait-for-device") + + +# Restart your device +def reboot(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + run_cmd("hdc shell reboot") + + +# Gets the current time, which is used as the file name part of the scraped data +def update_now_time(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global now_time + now_time = str(datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) + + +# Obtain the current device version number, which is used as the file name part of the scraped data +def update_now_version(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global now_version + now_version = str(run_cmd("hdc shell param get const.product.software.version")).replace("\n", "").replace(" ", "") + + +# Obtain the strings of process name and process ID +def get_p_name_id(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global p_name_id + cmd = "hdc shell \"pidof " + target_p_name + "\"" + pid = str(run_cmd(cmd)).replace("\n", "") + p_name_id = target_p_name + "-" + pid + + +# Obtain the main method of trace +def get_trace(): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: in") + global trace_file_name + trace_file_name = "trace-" + now_version + "-" + p_name_id + "-" + now_time + ".trace" + cmd = "hdc shell \"hitrace -b 40960 -t " + str(trace_duration) + " --overwrite hdf -o /data/log/this.trace\"" + result = run_cmd(cmd) + if "OpenRecording failed" in result: + reboot() + return + cmd = "hdc file recv /data/log/this.trace " + trace_file_name + result = run_cmd(cmd) + + +# Perform a one-time crawl of memory data for all processes configured +def get_data_once(): + update_now_time() + update_now_version() + get_p_name_id() + get_trace() + + +# Perform num fetch of the memory data of all processes configured at daily intervals +def get_data_more(num, daily): + for i in range(num): + get_data_once() + time.sleep(daily) + + +if __name__ == "__main__": + get_data_more(10000, 0) + pass -- Gitee From fad1e222622cfe753ea9bebc7e3ad5b4da2edf0a Mon Sep 17 00:00:00 2001 From: amunra03 Date: Wed, 31 Jul 2024 18:23:47 +0800 Subject: [PATCH 0017/1485] fix crash problem Signed-off-by: amunra03 --- nfc/hdi_service/nfc_impl.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/nfc/hdi_service/nfc_impl.cpp b/nfc/hdi_service/nfc_impl.cpp index 2439992009..53914bc0e2 100644 --- a/nfc/hdi_service/nfc_impl.cpp +++ b/nfc/hdi_service/nfc_impl.cpp @@ -251,6 +251,10 @@ void NfcImpl::OnRemoteDied(const wptr &object) int32_t NfcImpl::AddNfcDeathRecipient(const sptr &callbackObj) { + if (callbackObj == nullptr) { + HDF_LOGE("AddNfcDeathRecipient callbackobj nullptr"); + return HDF_FAILURE; + } const sptr &remote = OHOS::HDI::hdi_objcast(callbackObj); bool result = remote->AddDeathRecipient(remoteDeathRecipient_); if (!result) { @@ -262,6 +266,10 @@ int32_t NfcImpl::AddNfcDeathRecipient(const sptr &callbackObj) int32_t NfcImpl::RemoveNfcDeathRecipient(const sptr &callbackObj) { + if (callbackObj == nullptr) { + HDF_LOGE("RemoveNfcDeathRecipient callbackobj nullptr"); + return HDF_FAILURE; + } const sptr &remote = OHOS::HDI::hdi_objcast(callbackObj); bool result = remote->RemoveDeathRecipient(remoteDeathRecipient_); if (!result) { -- Gitee From 42a7a4e0a246f93c404f70b07383b35ab7adb8ad Mon Sep 17 00:00:00 2001 From: amunra03 Date: Wed, 31 Jul 2024 21:17:18 +0800 Subject: [PATCH 0018/1485] solve nfc host crash problem Signed-off-by: amunra03 --- nfc/hdi_service/nfc_impl.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/nfc/hdi_service/nfc_impl.cpp b/nfc/hdi_service/nfc_impl.cpp index 53914bc0e2..4fc2de7222 100644 --- a/nfc/hdi_service/nfc_impl.cpp +++ b/nfc/hdi_service/nfc_impl.cpp @@ -254,8 +254,12 @@ int32_t NfcImpl::AddNfcDeathRecipient(const sptr &callbackObj) if (callbackObj == nullptr) { HDF_LOGE("AddNfcDeathRecipient callbackobj nullptr"); return HDF_FAILURE; - } + } const sptr &remote = OHOS::HDI::hdi_objcast(callbackObj); + if (remote == nullptr) { + HDF_LOGE("AddNfcDeathRecipient remote nullptr"); + return HDF_FAILURE; + } bool result = remote->AddDeathRecipient(remoteDeathRecipient_); if (!result) { HDF_LOGE("NfcImpl AddDeathRecipient failed!"); @@ -269,8 +273,12 @@ int32_t NfcImpl::RemoveNfcDeathRecipient(const sptr &callbackObj) if (callbackObj == nullptr) { HDF_LOGE("RemoveNfcDeathRecipient callbackobj nullptr"); return HDF_FAILURE; - } + } const sptr &remote = OHOS::HDI::hdi_objcast(callbackObj); + if (remote == nullptr) { + HDF_LOGE("RemoveNfcDeathRecipient remote nullptr"); + return HDF_FAILURE; + } bool result = remote->RemoveDeathRecipient(remoteDeathRecipient_); if (!result) { HDF_LOGE("NfcImpl RemoveDeathRecipient failed!"); -- Gitee From 9df1d70dfe4e02d69a84d5130b870d2d123707b2 Mon Sep 17 00:00:00 2001 From: lixinsheng2 Date: Thu, 1 Aug 2024 12:51:28 +0800 Subject: [PATCH 0019/1485] Move input configuration to product Signed-off-by: lixinsheng2 --- base/hdf_peripheral.cfg | 5 ----- 1 file changed, 5 deletions(-) diff --git a/base/hdf_peripheral.cfg b/base/hdf_peripheral.cfg index f2a5312b4d..b577e25592 100644 --- a/base/hdf_peripheral.cfg +++ b/base/hdf_peripheral.cfg @@ -4,11 +4,6 @@ "cmds" : [ "chown input_user_host input_user_host /dev/hdf_input_host", "chown input_user_host input_user_host /dev/hdf_input_event1", - "chown input_user_host input_user_host /dev/hdf_input_event2", - "chown input_user_host input_user_host /dev/hdf_input_event3", - "chown input_user_host input_user_host /dev/hdf_input_event4", - "chown input_user_host input_user_host /dev/hdf_input_event5", - "chown input_user_host input_user_host /dev/hdf_input_event6", "chown hdf_devmgr uhdf_driver /dev/dev_mgr", "chown hdf_devmgr uhdf_driver /dev/hdf_kevent", "chown audio_host audio_host /dev/hdf_audio_render", -- Gitee From 5c3f700b01865da8876f436de2a2d0f191ff2c19 Mon Sep 17 00:00:00 2001 From: byndyx Date: Fri, 2 Aug 2024 10:38:44 +0800 Subject: [PATCH 0020/1485] codecheck Signed-off-by: byndyx --- .../common/utils/src/daudio_utils.cpp | 23 ------------------- .../dcamera_device/dmetadata_processor.cpp | 2 +- 2 files changed, 1 insertion(+), 24 deletions(-) diff --git a/distributed_audio/hdi_service/common/utils/src/daudio_utils.cpp b/distributed_audio/hdi_service/common/utils/src/daudio_utils.cpp index 3b55a67b49..d9d30e8a9a 100644 --- a/distributed_audio/hdi_service/common/utils/src/daudio_utils.cpp +++ b/distributed_audio/hdi_service/common/utils/src/daudio_utils.cpp @@ -257,24 +257,6 @@ int32_t WrapCJsonItem(const std::initializer_list &keys) { if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { @@ -288,11 +270,6 @@ bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list>& supportedFormats) { cJSON *photoObj = cJSON_GetObjectItemCaseSensitive(rootValue, "Photo"); - if (photoObj == nullptr) { + if (photoObj == nullptr || !cJSON_IsObject(photoObj)) { DHLOGE("Input Photo info is null."); return; } -- Gitee From a883fed20f17ef6f0ee234ef845106ebe1b95ea2 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 2 Aug 2024 06:28:08 +0000 Subject: [PATCH 0021/1485] =?UTF-8?q?usb=E5=AE=89=E5=85=A8=E5=91=8A?= =?UTF-8?q?=E8=AD=A6=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 2 +- usb/gadget/function/include/data_fifo.h | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 7c0411f115..45e94d562e 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -75,7 +75,7 @@ static void GetFilePath(const char *path, const char *fileName, char *filePath) return; } - if (filePath[strlen(path) - 1] != '/') { + if (strlen(path) > 0 && filePath[strlen(path) - 1] != '/') { if (strlen(path) + 1 >= MAX_PATHLEN - strlen(fileName)) { HDF_LOGE("%{public}s: file path too long", __func__); return; diff --git a/usb/gadget/function/include/data_fifo.h b/usb/gadget/function/include/data_fifo.h index 7736295aaf..848206db4d 100644 --- a/usb/gadget/function/include/data_fifo.h +++ b/usb/gadget/function/include/data_fifo.h @@ -64,6 +64,10 @@ static inline bool DataFifoIsEmpty(struct DataFifo *fifo) static inline bool DataFifoIsFull(struct DataFifo *fifo) { + if (fifo->size == 0) { + HDF_LOGE("%{public}s: Fifo size is zero", __func__); + return false; + } return DataFifoLen(fifo) > (fifo->size - 1); } @@ -79,6 +83,10 @@ static inline void DataFifoSkip(struct DataFifo *fifo, uint32_t size) static inline uint32_t DataFifoWrite(struct DataFifo *fifo, uint8_t *data, uint32_t size) { + if (fifo->size == 0) { + HDF_LOGE("%{public}s: Fifo size is zero", __func__); + return false; + } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; uint8_t *end; @@ -93,6 +101,10 @@ static inline uint32_t DataFifoWrite(struct DataFifo *fifo, uint8_t *data, uint3 static inline uint32_t DataFifoRead(struct DataFifo *fifo, uint8_t *data, uint32_t size) { + if (fifo->size == 0) { + HDF_LOGE("%{public}s: Fifo size is zero", __func__); + return false; + } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; uint8_t *end; -- Gitee From 48312ba22170c725e216e4dbb30400d03ba85346 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Fri, 2 Aug 2024 10:40:56 +0800 Subject: [PATCH 0022/1485] =?UTF-8?q?controltransfer=E5=85=BC=E5=AE=B9?= =?UTF-8?q?=E6=80=A7=E5=A2=9E=E5=BC=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hechaofan --- usb/hdi_service/include/usb_impl.h | 1 + usb/hdi_service/src/usb_impl.cpp | 17 +++++++++++++---- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index 171798d196..d7d74a4e78 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -110,6 +110,7 @@ private: void MakeGetActiveUsbControlParams( UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index); int32_t UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrParams, int32_t timeout); + int32_t CheckInput(HostDevice *dev, UsbControlParams *ctrParams); void MakeSetActiveUsbControlParams( UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index); static int32_t ReOpenDevice(HostDevice *port); diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 4a111e30b7..33e67eda0c 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -152,6 +152,16 @@ void UsbImpl::MakeGetActiveUsbControlParams( controlParams->size = length; } +int32_t UsbImpl::CheckInput(HostDevice *dev, UsbControlParams *ctrParams) +{ + if (dev == nullptr || dev->ctrDevHandle == nullptr || ctrParams == nullptr || + (ctrParams->data == nullptr && ctrParams->size != 0)) { + HDF_LOGE("%{public}s:invalid params", __func__); + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrParams, int32_t timeout) { UsbRequestParams params; @@ -160,11 +170,10 @@ int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrPara return HDF_FAILURE; } - if (dev == nullptr || dev->ctrDevHandle == nullptr || ctrParams == nullptr || ctrParams->data == nullptr) { - HDF_LOGE("%{public}s:invalid params", __func__); - return HDF_ERR_INVALID_PARAM; + if (CheckInput(dev, ctrParams) != HDF_SUCCESS) { + HDF_LOGE("%{public}s:UsbControlTransfer input invalid", __func__); } - + UsbRequest *request = nullptr; if (dev->ctrlReq == nullptr) { request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE); -- Gitee From cc8e926b68eacd149586f5b2a259b8b35e043a47 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 2 Aug 2024 06:46:44 +0000 Subject: [PATCH 0023/1485] update usb/gadget/function/include/data_fifo.h. Signed-off-by: luzhiye --- usb/gadget/function/include/data_fifo.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/usb/gadget/function/include/data_fifo.h b/usb/gadget/function/include/data_fifo.h index 848206db4d..0ec30645e8 100644 --- a/usb/gadget/function/include/data_fifo.h +++ b/usb/gadget/function/include/data_fifo.h @@ -85,7 +85,7 @@ static inline uint32_t DataFifoWrite(struct DataFifo *fifo, uint8_t *data, uint3 { if (fifo->size == 0) { HDF_LOGE("%{public}s: Fifo size is zero", __func__); - return false; + return HDF_FAILURE; } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; @@ -103,7 +103,7 @@ static inline uint32_t DataFifoRead(struct DataFifo *fifo, uint8_t *data, uint32 { if (fifo->size == 0) { HDF_LOGE("%{public}s: Fifo size is zero", __func__); - return false; + return HDF_FAILURE; } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; -- Gitee From 873d9eb3b874d6efe2bc1d7012e6232c28133442 Mon Sep 17 00:00:00 2001 From: liufeng Date: Fri, 2 Aug 2024 15:00:01 +0800 Subject: [PATCH 0024/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/test/demo/ohos_camera_demo.cpp | 34 +++---- camera/test/demo_3A/ohos_camera_demo_3a.cpp | 34 +++---- .../hdi/v1_1/src/camera_hdi_uttest_v1_1.cpp | 4 +- .../hdi/v1_1/src/camera_tag_uttest_v1_1.cpp | 89 ++++++++++++------- .../v1_1/src/front_camera_tag_uttest_v1_1.cpp | 44 ++++++--- camera/test/hdi/v1_1/src/hdi_common_v1_1.cpp | 4 +- 6 files changed, 131 insertions(+), 78 deletions(-) diff --git a/camera/test/demo/ohos_camera_demo.cpp b/camera/test/demo/ohos_camera_demo.cpp index 6f988a7b78..4ed6e84e62 100644 --- a/camera/test/demo/ohos_camera_demo.cpp +++ b/camera/test/demo/ohos_camera_demo.cpp @@ -838,7 +838,7 @@ RetCode OhosCameraDemo::GetFaceDetectMode(std::shared_ptr &abilit uint8_t faceDetectMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MODE error"); return RC_ERROR; } @@ -853,7 +853,7 @@ RetCode OhosCameraDemo::GetFocalLength(std::shared_ptr &ability) float focalLength = 0.0; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.f == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FOCAL_LENGTH error"); return RC_ERROR; } @@ -868,7 +868,7 @@ RetCode OhosCameraDemo::GetAvailableFocusModes(std::shared_ptr &a std::vector focusMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FOCUS_MODES error"); return RC_ERROR; } @@ -891,7 +891,7 @@ RetCode OhosCameraDemo::GetAvailableExposureModes(std::shared_ptr std::vector exposureMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_EXPOSURE_MODES error"); return RC_ERROR; } @@ -914,7 +914,7 @@ RetCode OhosCameraDemo::GetExposureCompensationRange(std::shared_ptr exposureCompensationRange; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_COMPENSATION_RANGE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_AE_COMPENSATION_RANGE error"); return RC_ERROR; } @@ -938,7 +938,7 @@ RetCode OhosCameraDemo::GetExposureCompensationSteps(std::shared_ptr &a std::vector meterModes; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_METER_MODES error"); return RC_ERROR; } @@ -978,7 +978,7 @@ RetCode OhosCameraDemo::GetAvailableFlashModes(std::shared_ptr &a std::vector flashModes; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FLASH_MODES error"); return RC_ERROR; } @@ -1001,7 +1001,7 @@ RetCode OhosCameraDemo::GetMirrorSupported(std::shared_ptr &abili uint8_t mirrorSupported; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED error"); return RC_ERROR; } @@ -1016,7 +1016,7 @@ RetCode OhosCameraDemo::GetStreamBasicConfigurations(std::shared_ptr streamBasicConfigurations; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS error"); return RC_ERROR; } @@ -1040,7 +1040,7 @@ RetCode OhosCameraDemo::GetFpsRange(std::shared_ptr &ability) std::vector fpsRange; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FPS_RANGES error"); return RC_ERROR; } @@ -1064,7 +1064,7 @@ RetCode OhosCameraDemo::GetCameraPosition(std::shared_ptr &abilit uint8_t cameraPosition; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_POSITION error"); return RC_ERROR; } @@ -1080,7 +1080,7 @@ RetCode OhosCameraDemo::GetCameraType(std::shared_ptr &ability) uint8_t cameraType; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_TYPE error"); return RC_ERROR; } @@ -1096,7 +1096,7 @@ RetCode OhosCameraDemo::GetCameraConnectionType(std::shared_ptr & uint8_t cameraConnectionType; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_CONNECTION_TYPE error"); return RC_ERROR; } @@ -1112,7 +1112,7 @@ RetCode OhosCameraDemo::GetFaceDetectMaxNum(std::shared_ptr &abil uint8_t faceDetectMaxNum; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MAX_NUM, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MAX_NUM error"); return RC_ERROR; } @@ -1140,7 +1140,7 @@ int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector uint8_t focusMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_FOCUS_MODE error"); return RC_ERROR; } @@ -1153,7 +1153,7 @@ int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector uint8_t exposureMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error"); return RC_ERROR; } diff --git a/camera/test/demo_3A/ohos_camera_demo_3a.cpp b/camera/test/demo_3A/ohos_camera_demo_3a.cpp index 30e3477831..02c10134da 100644 --- a/camera/test/demo_3A/ohos_camera_demo_3a.cpp +++ b/camera/test/demo_3A/ohos_camera_demo_3a.cpp @@ -846,7 +846,7 @@ RetCode OhosCameraDemo::GetFaceDetectMode(std::shared_ptr &abilit uint8_t faceDetectMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MODE error"); return RC_ERROR; } @@ -861,7 +861,7 @@ RetCode OhosCameraDemo::GetFocalLength(std::shared_ptr &ability) float focalLength = 0.0; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.f == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FOCAL_LENGTH error"); return RC_ERROR; } @@ -876,7 +876,7 @@ RetCode OhosCameraDemo::GetAvailableFocusModes(std::shared_ptr &a std::vector focusMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FOCUS_MODES error"); return RC_ERROR; } @@ -899,7 +899,7 @@ RetCode OhosCameraDemo::GetAvailableExposureModes(std::shared_ptr std::vector exposureMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_EXPOSURE_MODES error"); return RC_ERROR; } @@ -922,7 +922,7 @@ RetCode OhosCameraDemo::GetExposureCompensationRange(std::shared_ptr exposureCompensationRange; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_AE_COMPENSATION_RANGE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_AE_COMPENSATION_RANGE error"); return RC_ERROR; } @@ -946,7 +946,7 @@ RetCode OhosCameraDemo::GetExposureCompensationSteps(std::shared_ptr &a std::vector meterModes; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_METER_MODES error"); return RC_ERROR; } @@ -986,7 +986,7 @@ RetCode OhosCameraDemo::GetAvailableFlashModes(std::shared_ptr &a std::vector flashModes; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FLASH_MODES error"); return RC_ERROR; } @@ -1009,7 +1009,7 @@ RetCode OhosCameraDemo::GetMirrorSupported(std::shared_ptr &abili uint8_t mirrorSupported; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED error"); return RC_ERROR; } @@ -1024,7 +1024,7 @@ RetCode OhosCameraDemo::GetStreamBasicConfigurations(std::shared_ptr streamBasicConfigurations; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS error"); return RC_ERROR; } @@ -1048,7 +1048,7 @@ RetCode OhosCameraDemo::GetFpsRange(std::shared_ptr &ability) std::vector fpsRange; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.i32 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_FPS_RANGES error"); return RC_ERROR; } @@ -1072,7 +1072,7 @@ RetCode OhosCameraDemo::GetCameraPosition(std::shared_ptr &abilit uint8_t cameraPosition; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_POSITION error"); return RC_ERROR; } @@ -1088,7 +1088,7 @@ RetCode OhosCameraDemo::GetCameraType(std::shared_ptr &ability) uint8_t cameraType; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_TYPE error"); return RC_ERROR; } @@ -1104,7 +1104,7 @@ RetCode OhosCameraDemo::GetCameraConnectionType(std::shared_ptr & uint8_t cameraConnectionType; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_ABILITY_CAMERA_CONNECTION_TYPE error"); return RC_ERROR; } @@ -1120,7 +1120,7 @@ RetCode OhosCameraDemo::GetFaceDetectMaxNum(std::shared_ptr &abil uint8_t faceDetectMaxNum; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_DETECT_MAX_NUM, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_STATISTICS_FACE_DETECT_MAX_NUM error"); return RC_ERROR; } @@ -1146,7 +1146,7 @@ int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector uint8_t focusMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_FOCUS_MODE error"); return RC_ERROR; } @@ -1159,7 +1159,7 @@ int32_t DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector uint8_t exposureMode; camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_EXPOSURE_MODE, &entry); - if (ret != 0) { + if (ret != 0 || entry.data.u8 == nullptr || entry.count <= 0) { CAMERA_LOGE("demo test: get OHOS_CONTROL_EXPOSURE_MODE error"); return RC_ERROR; } diff --git a/camera/test/hdi/v1_1/src/camera_hdi_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/camera_hdi_uttest_v1_1.cpp index 5fc7c70880..e87ba28170 100644 --- a/camera/test/hdi/v1_1/src/camera_hdi_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/camera_hdi_uttest_v1_1.cpp @@ -187,7 +187,7 @@ HWTEST_F(CameraHdiUtTestV1_1, Camera_Device_Hdi_V1_1_009, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry); if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - CAMERA_LOGE("print tag value start."); + CAMERA_LOGI("print tag value start."); constexpr size_t step = 10; // print step std::stringstream ss; for (size_t i = 0; i < entry.count; i++) { @@ -198,7 +198,7 @@ HWTEST_F(CameraHdiUtTestV1_1, Camera_Device_Hdi_V1_1_009, TestSize.Level1) ss.str(""); } } - CAMERA_LOGE("print tag value end."); + CAMERA_LOGI("print tag value end."); } } diff --git a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp index 933d96dc05..3d03f638f4 100644 --- a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp @@ -38,14 +38,18 @@ bool isTagValueExistsU8(std::shared_ptr ability, uint32_t tag, u common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == value) { - return true; + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } } + return false; + } else { + printf("Find CameraMetadata fail!\n"); + CAMERA_LOGE("Find CameraMetadata fail!"); + return false; } - return false; } void invalidParmTestU8(int tag, uint8_t value) @@ -84,14 +88,15 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_001, TestSize.Level1) common_metadata_header_t* data = cameraTest->ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(ret, 0); - CAMERA_LOGI("get OHOS_ABILITY_CAMERA_MODES success"); - EXPECT_EQ(META_TYPE_BYTE, entry.data_type); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == HDI::Camera::V1_0::OperationMode::NORMAL) { - CAMERA_LOGI("OperationMode::NORMAL found!"); - } else if (entry.data.u8[i] == OHOS::HDI::Camera::V1_1::PORTRAIT) { - CAMERA_LOGI("OperationMode::PORTRAIT found!"); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + CAMERA_LOGI("get OHOS_ABILITY_CAMERA_MODES success"); + EXPECT_EQ(META_TYPE_BYTE, entry.data_type); + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == HDI::Camera::V1_0::OperationMode::NORMAL) { + CAMERA_LOGE("OperationMode::NORMAL found!"); + } else if (entry.data.u8[i] == OHOS::HDI::Camera::V1_1::PORTRAIT) { + CAMERA_LOGI("OperationMode::PORTRAIT found!"); + } } } } @@ -118,9 +123,14 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_002, TestSize.Level1) printf("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { - CAMERA_LOGI("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is 0"); + printf("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is 0 ...\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is 0 ..."); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); @@ -161,9 +171,14 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_003, TestSize.Level1) printf("OHOS_ABILITY_SCENE_FILTER_TYPES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { - CAMERA_LOGI("OHOS_ABILITY_SCENE_FILTER_TYPES value count is 0"); + printf("OHOS_ABILITY_SCENE_FILTER_TYPES value count is 0 ...\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_FILTER_TYPES value count is 0 ..."); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_SCENE_FILTER_TYPES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_FILTER_TYPES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_SCENE_FILTER_VALUES : %d\n", entry.data.u8[i]); @@ -205,9 +220,14 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_005, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { - CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is 0"); + printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is 0 ...\n"); + CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is 0 ..."); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES : %d\n", entry.data.u8[i]); @@ -242,17 +262,26 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_009, TestSize.Level1) //obtain an FPS value through OHOS_CONTROL_FPS_RANGES.(An interval. //for example, [30, 30], indicating 30 frames per second) - EXPECT_NE(0, entry.count); - std::shared_ptr meta = std::make_shared(100, 200); - int32_t tagValue[2] = {entry.data.i32[0], entry.data.i32[0]}; - meta->addEntry(OHOS_CONTROL_FPS_RANGES, &tagValue, 2); + if (entry.count == 0) { + printf("OHOS_ABILITY_CUSTOM_VIDEO_FPS value count is 0 ...\n"); + CAMERA_LOGI("OHOS_ABILITY_CUSTOM_VIDEO_FPS value count is 0 ..."); + return; + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!"); + return; + } else if { + std::shared_ptr meta = std::make_shared(100, 200); + int32_t tagValue[2] = {entry.data.i32[0], entry.data.i32[0]}; + meta->addEntry(OHOS_CONTROL_FPS_RANGES, &tagValue, 2); - std::shared_ptr metaInvalid = std::make_shared(100, 200); - int32_t valueInvalid[2] = {1000, 1000}; - metaInvalid->addEntry(OHOS_CONTROL_FPS_RANGES, &valueInvalid, 2); - std::vector metaVec; - MetadataUtils::ConvertMetadataToVec(metaInvalid, metaVec); - cameraTest->rc = cameraTest->cameraDevice->UpdateSettings(metaVec); + std::shared_ptr metaInvalid = std::make_shared(100, 200); + int32_t valueInvalid[2] = {1000, 1000}; + metaInvalid->addEntry(OHOS_CONTROL_FPS_RANGES, &valueInvalid, 2); + std::vector metaVec; + MetadataUtils::ConvertMetadataToVec(metaInvalid, metaVec); + cameraTest->rc = cameraTest->cameraDevice->UpdateSettings(metaVec); + } } void CameraTagUtTestV1_1::TakePhotoWithTags(std::shared_ptr meta) diff --git a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp index 18c9bcc4e3..5a39aea8f6 100644 --- a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp @@ -38,14 +38,18 @@ bool g_isFrontTagValueExistsU8(std::shared_ptr ability, uint32_t common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == value) { - return true; + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } } + return false; + } else { + printf("Find CameraMetadata fail!\n"); + CAMERA_LOGE("Find CameraMetadata fail!"); + return false; } - return false; } /** @@ -68,9 +72,14 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_004, TestSize.Level1) printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { + printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES value count is 0"); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_SCENE_BEAUTY_VALUES : %d\n", entry.data.u8[i]); @@ -111,9 +120,14 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_006, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { + printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES value count is 0"); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES : %d\n", entry.data.u8[i]); @@ -155,9 +169,14 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_007, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { + printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0"); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES : %d\n", entry.data.i32[i]); @@ -199,9 +218,14 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_008, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES value count is %d\n", entry.count); // Take a photo using the blurring effect TakePhotoWithTags() if (entry.count == 0) { + printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES value count is 0"); return; - } else { + } else if (entry.data.u8 != nullptr) { + printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!\n"); + CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!"); + return; + } else if { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES : %d\n", entry.data.u8[i]); diff --git a/camera/test/hdi/v1_1/src/hdi_common_v1_1.cpp b/camera/test/hdi/v1_1/src/hdi_common_v1_1.cpp index 63670fec88..76dd029bfb 100644 --- a/camera/test/hdi/v1_1/src/hdi_common_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/hdi_common_v1_1.cpp @@ -214,7 +214,7 @@ void Test::DefaultInfosAnalyze( camera_metadata_item_t entry = {}; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face ids : %{public}d", id); @@ -222,7 +222,7 @@ void Test::DefaultInfosAnalyze( } ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face rectangles : %{public}d", id); -- Gitee From 3ff807e25d4b225993325407e8e362a6c59a5be1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=AB=98=E5=85=B4=E7=83=A8?= Date: Thu, 1 Aug 2024 17:02:54 +0800 Subject: [PATCH 0025/1485] wlan ext add network MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 高兴烨 --- wlan/client/include/wifi_driver_client.h | 2 ++ wlan/client/src/netlink/netlink_cmd_adapter.c | 7 ++++++- wlan/client/src/sbuf/sbuf_cmd_adapter.c | 8 ++++++++ wlan/test/unittest/client/hdf_client_test.cpp | 17 +++++++++++++++++ 4 files changed, 33 insertions(+), 1 deletion(-) diff --git a/wlan/client/include/wifi_driver_client.h b/wlan/client/include/wifi_driver_client.h index 26d7dd2613..1a37fb6675 100644 --- a/wlan/client/include/wifi_driver_client.h +++ b/wlan/client/include/wifi_driver_client.h @@ -86,6 +86,7 @@ enum WifiIfType { WIFI_IFTYPE_P2P_CLIENT, WIFI_IFTYPE_P2P_GO, WIFI_IFTYPE_P2P_DEVICE, + WIFI_IFTYPE_CHBA, WIFI_IFTYPE_MAX, }; @@ -364,6 +365,7 @@ int32_t WifiSendActionFrame(const char *ifName, uint32_t txChannel, const uint8_ int32_t WifiRegisterActionFrameReceiver(const char *ifName, const uint8_t *match, uint32_t matchLen); int32_t WifiSetPowerSaveMode(const char *ifName, int32_t frequency, int32_t mode); int32_t WifiSetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable); +int32_t WifiInstallWlanExtParam(const char *ifName, const InstallWlanParam *param); /* wpa related interface */ #define MAX_NR_CIPHER_SUITES 5 diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index a5a2e5f0bb..1933892cce 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -58,6 +58,7 @@ #define STR_WLAN1 "wlan1" #define STR_P2P0 "p2p0" #define STR_P2P0_X "p2p0-" +#define STR_CHBA "chba0" #define NET_DEVICE_INFO_PATH "/sys/class/net" #define PRIMARY_ID_POWER_MODE 0x8bfd @@ -115,6 +116,7 @@ static inline uint32_t BIT(uint8_t x) #define WLAN_IFACE_LENGTH 4 #define P2P_IFACE_LENGTH 3 +#define CHBA_IFACE_LENGTH 4 #ifndef KERNEL_VERSION #define KERNEL_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + ((c) > 255 ? 255 : (c))) #endif @@ -1001,7 +1003,8 @@ static int32_t ParserValidFreq(struct nl_msg *msg, void *arg) static bool IsWifiIface(const char *name) { - if (strncmp(name, "wlan", WLAN_IFACE_LENGTH) != 0 && strncmp(name, "p2p", P2P_IFACE_LENGTH) != 0) { + if (strncmp(name, "wlan", WLAN_IFACE_LENGTH) != 0 && strncmp(name, "p2p", P2P_IFACE_LENGTH) != 0 && + strncmp(name, "chba", CHBA_IFACE_LENGTH) != 0) { /* not a wifi interface; ignore it */ return false; } else { @@ -1082,6 +1085,8 @@ int32_t GetUsableNetworkInfo(struct NetworkInfoResult *result) } else if (strncmp(result->infos[i].name, STR_P2P0_X, strlen(STR_P2P0_X)) == 0) { result->infos[i].supportMode[WIFI_IFTYPE_P2P_CLIENT] = 1; result->infos[i].supportMode[WIFI_IFTYPE_P2P_GO] = 1; + } else if (strncmp(result->infos[i].name, STR_CHBA, strlen(STR_CHBA)) == 0) { + result->infos[i].supportMode[WIFI_IFTYPE_CHBA] = 1; } } return RET_CODE_SUCCESS; diff --git a/wlan/client/src/sbuf/sbuf_cmd_adapter.c b/wlan/client/src/sbuf/sbuf_cmd_adapter.c index b769d746a8..ec7c9c1acd 100644 --- a/wlan/client/src/sbuf/sbuf_cmd_adapter.c +++ b/wlan/client/src/sbuf/sbuf_cmd_adapter.c @@ -1188,6 +1188,14 @@ int32_t WifiSetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable) return RET_CODE_NOT_SUPPORT; } +int32_t WifiInstallWlanExtParam(const char *ifName, const InstallWlanParam *param) +{ + (void)ifName; + (void)param; + + return RET_CODE_NOT_SUPPORT; +} + #ifdef __cplusplus #if __cplusplus } diff --git a/wlan/test/unittest/client/hdf_client_test.cpp b/wlan/test/unittest/client/hdf_client_test.cpp index a3b4dd829e..8d2a0a8d62 100644 --- a/wlan/test/unittest/client/hdf_client_test.cpp +++ b/wlan/test/unittest/client/hdf_client_test.cpp @@ -1028,6 +1028,23 @@ HWTEST_F(WifiClientTest, WifiSetDpiMarkRule028, TestSize.Level1) int32_t buf = 0; WifiSetDpiMarkRule(srcAddr, dstAddr, buf); } +/** + * @tc.name: WifiInstallWlanExtParam029 + * @tc.desc: install wlan ext param + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(WifiClientTest, WifiInstallWlanExtParam029, TestSize.Level1) +{ + int32_t ret; + const char *ifNameInvalid = "wlanTest"; + InstallWlanParam param; + param.id = 0; + param.suite = 0; + param.len = 0; + ret = WifiInstallWlanExtParam(ifNameInvalid, ¶m); + EXPECT_EQ(RET_CODE_FAILURE, ret); +} /** * @tc.name: WpaEventReport * @tc.desc: set rx remain On channel test -- Gitee From 66562a2772ec3d24b7e3ef78023104ede48cfd7d Mon Sep 17 00:00:00 2001 From: liufeng Date: Fri, 2 Aug 2024 16:31:35 +0800 Subject: [PATCH 0026/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../hdi/v1_1/src/camera_tag_uttest_v1_1.cpp | 17 ++++++++--------- .../v1_1/src/front_camera_tag_uttest_v1_1.cpp | 11 +++++------ 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp index 3d03f638f4..6497ae82f0 100644 --- a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp @@ -44,12 +44,11 @@ bool isTagValueExistsU8(std::shared_ptr ability, uint32_t tag, u return true; } } - return false; } else { printf("Find CameraMetadata fail!\n"); CAMERA_LOGE("Find CameraMetadata fail!"); - return false; } + return false; } void invalidParmTestU8(int tag, uint8_t value) @@ -88,7 +87,7 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_001, TestSize.Level1) common_metadata_header_t* data = cameraTest->ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { CAMERA_LOGI("get OHOS_ABILITY_CAMERA_MODES success"); EXPECT_EQ(META_TYPE_BYTE, entry.data_type); for (int i = 0; i < entry.count; i++) { @@ -126,11 +125,11 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_002, TestSize.Level1) printf("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is 0 ...\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES value count is 0 ..."); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); @@ -174,11 +173,11 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_003, TestSize.Level1) printf("OHOS_ABILITY_SCENE_FILTER_TYPES value count is 0 ...\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_FILTER_TYPES value count is 0 ..."); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_SCENE_FILTER_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_FILTER_TYPES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_SCENE_FILTER_VALUES : %d\n", entry.data.u8[i]); @@ -227,7 +226,7 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_005, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES : %d\n", entry.data.u8[i]); @@ -270,7 +269,7 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_009, TestSize.Level1) printf("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!"); return; - } else if { + } else { std::shared_ptr meta = std::make_shared(100, 200); int32_t tagValue[2] = {entry.data.i32[0], entry.data.i32[0]}; meta->addEntry(OHOS_CONTROL_FPS_RANGES, &tagValue, 2); diff --git a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp index 5a39aea8f6..9f4f8ae17a 100644 --- a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp @@ -44,12 +44,11 @@ bool g_isFrontTagValueExistsU8(std::shared_ptr ability, uint32_t return true; } } - return false; } else { printf("Find CameraMetadata fail!\n"); CAMERA_LOGE("Find CameraMetadata fail!"); - return false; } + return false; } /** @@ -75,7 +74,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_004, TestSize.Level1) printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES value count is 0"); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); return; @@ -123,7 +122,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_006, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES value count is 0"); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!"); return; @@ -172,7 +171,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_007, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0"); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); return; @@ -221,7 +220,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_008, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES value count is 0"); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!"); return; -- Gitee From 2065ac2a707c649b5966bfd9ea6af8e841474bc4 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Fri, 2 Aug 2024 08:55:34 +0000 Subject: [PATCH 0027/1485] update usb/hdi_service/include/usb_impl.h. Signed-off-by: hechaofan --- usb/hdi_service/include/usb_impl.h | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index d7d74a4e78..171798d196 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -110,7 +110,6 @@ private: void MakeGetActiveUsbControlParams( UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index); int32_t UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrParams, int32_t timeout); - int32_t CheckInput(HostDevice *dev, UsbControlParams *ctrParams); void MakeSetActiveUsbControlParams( UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index); static int32_t ReOpenDevice(HostDevice *port); -- Gitee From d97e7b5823c08c65e26eb0da9867342e1c86e623 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Fri, 2 Aug 2024 08:58:25 +0000 Subject: [PATCH 0028/1485] update usb/hdi_service/src/usb_impl.cpp. Signed-off-by: hechaofan --- usb/hdi_service/src/usb_impl.cpp | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 33e67eda0c..8bfbdb0bb8 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -152,16 +152,6 @@ void UsbImpl::MakeGetActiveUsbControlParams( controlParams->size = length; } -int32_t UsbImpl::CheckInput(HostDevice *dev, UsbControlParams *ctrParams) -{ - if (dev == nullptr || dev->ctrDevHandle == nullptr || ctrParams == nullptr || - (ctrParams->data == nullptr && ctrParams->size != 0)) { - HDF_LOGE("%{public}s:invalid params", __func__); - return HDF_ERR_INVALID_PARAM; - } - return HDF_SUCCESS; -} - int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrParams, int32_t timeout) { UsbRequestParams params; @@ -170,10 +160,10 @@ int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrPara return HDF_FAILURE; } - if (CheckInput(dev, ctrParams) != HDF_SUCCESS) { - HDF_LOGE("%{public}s:UsbControlTransfer input invalid", __func__); + if (dev == nullptr || dev->ctrDevHandle == nullptr || ctrParams == nullptr) { + HDF_LOGE("%{public}s:invalid params", __func__); + return HDF_ERR_INVALID_PARAM; } - UsbRequest *request = nullptr; if (dev->ctrlReq == nullptr) { request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE); -- Gitee From 7a3e346740879388523edf016c947c0f3b6c5659 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Fri, 2 Aug 2024 08:59:02 +0000 Subject: [PATCH 0029/1485] update usb/hdi_service/src/usb_impl.cpp. Signed-off-by: hechaofan --- usb/hdi_service/src/usb_impl.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 8bfbdb0bb8..caab5b9ae1 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -164,6 +164,7 @@ int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrPara HDF_LOGE("%{public}s:invalid params", __func__); return HDF_ERR_INVALID_PARAM; } + UsbRequest *request = nullptr; if (dev->ctrlReq == nullptr) { request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE); -- Gitee From ac438922f95ec2058c51ff4fc8593db52478652e Mon Sep 17 00:00:00 2001 From: hechaofan Date: Fri, 2 Aug 2024 08:59:33 +0000 Subject: [PATCH 0030/1485] update usb/hdi_service/src/usb_impl.cpp. Signed-off-by: hechaofan --- usb/hdi_service/src/usb_impl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index caab5b9ae1..8dfbeb0889 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -164,7 +164,7 @@ int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrPara HDF_LOGE("%{public}s:invalid params", __func__); return HDF_ERR_INVALID_PARAM; } - + UsbRequest *request = nullptr; if (dev->ctrlReq == nullptr) { request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE); -- Gitee From e5586de9ae259de7f514205b36a4b568be1e6110 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 08:59:48 +0000 Subject: [PATCH 0031/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 90ec957d95..3ebf93cc66 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -919,10 +919,7 @@ struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct Audio for (index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) { if ((renderPriv->renderInfos[index] != NULL) && - (renderPriv->renderInfos[index]->desc.pins == pin) && - (renderPriv->renderInfos[index]->streamType == attrs->type) && - (renderPriv->renderInfos[index]->sampleRate == attrs->sampleRate) && - (renderPriv->renderInfos[index]->channelCount == attrs->channelCount)) { + (renderPriv->renderInfos[index]->streamType == attrs->type)) { *rendrId = renderPriv->renderInfos[index]->renderId; renderPriv->renderInfos[index]->usrCount++; return &renderPriv->renderInfos[index]->render; -- Gitee From 9e859832da86304fcb4b209c7c0928a5a8343a8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 09:04:49 +0000 Subject: [PATCH 0032/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index 592ce664bb..d2b8a4727d 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -118,6 +118,11 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); + if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_OUT_HDMI || desc->pins >= PIN_IN_MIC) { + AUDIO_FUNC_LOGE("invalid pin [%{public}d]", desc->pins); + return HDF_FAILURE; + } + pthread_mutex_lock(&g_adapterMutex); *render = FindRenderCreated(desc->pins, attrs, renderId); if (*render != NULL) { -- Gitee From 5ee41ff2bd6ff74b9f62799aae468800fe701552 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Fri, 2 Aug 2024 09:12:20 +0000 Subject: [PATCH 0033/1485] modify MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/src/linux_adapter.c | 1 - usb/ddk/host/src/usb_io_manage.c | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 9c6496a4f3..a258bcdaba 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -459,7 +459,6 @@ static int32_t OsSubmitControlRequest(struct UsbHostRequest *request) } return HDF_ERR_IO; } - RawUsbMemFree(urb); return HDF_SUCCESS; } diff --git a/usb/ddk/host/src/usb_io_manage.c b/usb/ddk/host/src/usb_io_manage.c index cb992c8fd1..53d11b5d90 100644 --- a/usb/ddk/host/src/usb_io_manage.c +++ b/usb/ddk/host/src/usb_io_manage.c @@ -88,11 +88,11 @@ static int32_t IoSendProcess(const void *interfacePoolArg) break; } - RawUsbMemFree(submitRequest->urbs); if (i >= USB_IO_SUBMIT_RETRY_TIME_CNT) { HDF_LOGE("%{public}s:%{public}d submit request failed", __func__, __LINE__); submitRequest->status = USB_REQUEST_ERROR; UsbIoSetRequestCompletionInfo(submitRequest); + RawUsbMemFree(submitRequest->urbs); continue; } } -- Gitee From 29f86fb0e4abdfa4d5e4283c8d0abdbd868ad56c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 09:13:00 +0000 Subject: [PATCH 0034/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index d2b8a4727d..3675978481 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -118,7 +118,8 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); - if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_OUT_HDMI || desc->pins >= PIN_IN_MIC) { + if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_OUT_HDMI || + desc->pins == PIN_NONE || desc->pins >= PIN_IN_MIC) { AUDIO_FUNC_LOGE("invalid pin [%{public}d]", desc->pins); return HDF_FAILURE; } -- Gitee From 3f9117329291a7484c261a77663c86eec5a67739 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 2 Aug 2024 09:49:35 +0000 Subject: [PATCH 0035/1485] update usb/gadget/function/include/data_fifo.h. Signed-off-by: luzhiye --- usb/gadget/function/include/data_fifo.h | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/usb/gadget/function/include/data_fifo.h b/usb/gadget/function/include/data_fifo.h index 0ec30645e8..b64c904d41 100644 --- a/usb/gadget/function/include/data_fifo.h +++ b/usb/gadget/function/include/data_fifo.h @@ -36,6 +36,10 @@ struct DataFifo { /* DataFifo Helper function */ static inline void DataFifoInit(struct DataFifo *fifo, uint32_t size, void *data) { + if (size == 0) { + HDF_LOGE("%{public}s: Fifo size is zero", __func__); + return; + } fifo->rdIdx = 0; fifo->wrIdx = 0; fifo->size = size; @@ -64,10 +68,6 @@ static inline bool DataFifoIsEmpty(struct DataFifo *fifo) static inline bool DataFifoIsFull(struct DataFifo *fifo) { - if (fifo->size == 0) { - HDF_LOGE("%{public}s: Fifo size is zero", __func__); - return false; - } return DataFifoLen(fifo) > (fifo->size - 1); } @@ -83,10 +83,6 @@ static inline void DataFifoSkip(struct DataFifo *fifo, uint32_t size) static inline uint32_t DataFifoWrite(struct DataFifo *fifo, uint8_t *data, uint32_t size) { - if (fifo->size == 0) { - HDF_LOGE("%{public}s: Fifo size is zero", __func__); - return HDF_FAILURE; - } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; uint8_t *end; @@ -101,10 +97,6 @@ static inline uint32_t DataFifoWrite(struct DataFifo *fifo, uint8_t *data, uint3 static inline uint32_t DataFifoRead(struct DataFifo *fifo, uint8_t *data, uint32_t size) { - if (fifo->size == 0) { - HDF_LOGE("%{public}s: Fifo size is zero", __func__); - return HDF_FAILURE; - } uint32_t mask = fifo->size - 1; uint8_t *buf = (uint8_t *)fifo->data; uint8_t *end; -- Gitee From ac112b688a57b2fceba7e42b51e0b66e939a27a3 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Fri, 2 Aug 2024 18:05:09 +0800 Subject: [PATCH 0036/1485] commit msg Signed-off-by: xuxuehai --- .../primary_impl/src/audio_render.c | 8 +- .../alsa_adapter/src/alsa_snd_capture.c | 84 ++++------ .../alsa_adapter/src/alsa_snd_render.c | 70 +++----- .../alsa_adapter/src/alsa_soundcard.c | 155 +++++++----------- 4 files changed, 121 insertions(+), 196 deletions(-) diff --git a/audio/hdi_service/primary_impl/src/audio_render.c b/audio/hdi_service/primary_impl/src/audio_render.c index 2f78eeaaa1..6a325009c1 100644 --- a/audio/hdi_service/primary_impl/src/audio_render.c +++ b/audio/hdi_service/primary_impl/src/audio_render.c @@ -835,12 +835,16 @@ int32_t AudioRenderRenderFrame( struct IAudioRender *render, const int8_t *frame, uint32_t frameLen, uint64_t *replyBytes) { struct AudioHwRender *hwRender = (struct AudioHwRender *)render; - if (hwRender == NULL || frame == NULL || replyBytes == NULL || - hwRender->renderParam.frameRenderMode.buffer == NULL) { + if (hwRender == NULL || frame == NULL || replyBytes == NULL) { AUDIO_FUNC_LOGE("Render Frame Paras is NULL!"); return AUDIO_ERR_INVALID_PARAM; } pthread_mutex_lock(&hwRender->renderParam.frameRenderMode.mutex); + if (hwRender->renderParam.frameRenderMode.buffer == NULL) { + pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); + AUDIO_FUNC_LOGE("Render Frame buffer is NULL!"); + return AUDIO_ERR_INVALID_PARAM; + } if (frameLen > FRAME_DATA) { pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); AUDIO_FUNC_LOGE("Out of FRAME_DATA size!"); diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index 5a78cfe5da..e2aa36472c 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -66,14 +66,13 @@ static int32_t CaptureFreeMemory(void) static int32_t SetHWParamsSub( struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params, snd_pcm_access_t access) { - int32_t ret; snd_pcm_format_t pcmFormat; snd_pcm_t *handle = cardIns->pcmHandle; struct AlsaCapture *captureIns = (struct AlsaCapture *)cardIns; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(params); - ret = snd_pcm_hw_params_set_rate_resample(handle, params, captureIns->resample); + int32_t ret = snd_pcm_hw_params_set_rate_resample(handle, params, captureIns->resample); if (ret < 0) { AUDIO_FUNC_LOGE("Resampling setup failed for capture: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -111,15 +110,13 @@ static int32_t SetHWParamsSub( static int32_t SetHWRate(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) { - int32_t ret; - uint32_t rRate; int32_t dir = 0; /* dir Value range (-1,0,1) */ CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(params); /* set the stream rate */ - rRate = cardIns->hwParams.rate; - ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); + uint32_t rRate = cardIns->hwParams.rate; + int32_t ret = snd_pcm_hw_params_set_rate_near(cardIns->pcmHandle, params, &rRate, &dir); if (ret < 0) { AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", cardIns->hwParams.rate, snd_strerror(ret)); @@ -142,14 +139,13 @@ static int32_t SetHWRate(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *par static int32_t SetHWBuffer(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) { - int32_t ret; int32_t dir = 0; /* dir Value range (-1,0,1) */ snd_pcm_uframes_t size = 0; struct AlsaCapture *captureIns = (struct AlsaCapture *)cardIns; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(params); - ret = snd_pcm_hw_params_set_buffer_time_near(cardIns->pcmHandle, params, &captureIns->bufferTime, &dir); + int32_t ret = snd_pcm_hw_params_set_buffer_time_near(cardIns->pcmHandle, params, &captureIns->bufferTime, &dir); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set buffer time %{public}u for capture: %{public}s", captureIns->bufferTime, snd_strerror(ret)); @@ -168,14 +164,13 @@ static int32_t SetHWBuffer(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *p static int32_t SetHWPeriod(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *params) { - int32_t ret; int32_t dir = 0; /* dir Value range (-1,0,1) */ snd_pcm_uframes_t size = 0; struct AlsaCapture *captureIns = (struct AlsaCapture*)cardIns; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(params); - ret = snd_pcm_hw_params_set_period_time_near(cardIns->pcmHandle, params, &captureIns->periodTime, &dir); + int32_t ret = snd_pcm_hw_params_set_period_time_near(cardIns->pcmHandle, params, &captureIns->periodTime, &dir); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to set period time %{public}u for capture: %{public}s", captureIns->periodTime, snd_strerror(ret)); @@ -194,14 +189,13 @@ static int32_t SetHWPeriod(struct AlsaSoundCard *cardIns, snd_pcm_hw_params_t *p static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) { - int32_t ret; snd_pcm_hw_params_t *hwParams = NULL; snd_pcm_t *handle = cardIns->pcmHandle; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(handle); snd_pcm_hw_params_alloca(&hwParams); - ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters + int32_t ret = snd_pcm_hw_params_any(handle, hwParams); // choose all parameters if (ret < 0) { AUDIO_FUNC_LOGE("Broken configuration for capture: no configurations available: %{public}s.", snd_strerror(ret)); @@ -247,7 +241,6 @@ static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t acces static int32_t SetSWParams(struct AlsaSoundCard *cardIns) { - int32_t ret; /* The time when the application starts reading data */ snd_pcm_sframes_t startThresholdSize = 1; snd_pcm_sw_params_t *swParams = NULL; @@ -258,7 +251,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) snd_pcm_sw_params_alloca(&swParams); /* get the current swparams */ - ret = snd_pcm_sw_params_current(handle, swParams); + int32_t ret = snd_pcm_sw_params_current(handle, swParams); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -303,11 +296,10 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) static int32_t ResetCaptureParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) { - int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(cardIns->pcmHandle); - ret = SetHWParams(cardIns, access); + int32_t ret = SetHWParams(cardIns, access); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret); return ret; @@ -324,12 +316,11 @@ static int32_t ResetCaptureParams(struct AlsaSoundCard *cardIns, snd_pcm_access_ static int32_t UpdateSetParams(struct AlsaSoundCard *cardIns) { - int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(cardIns->pcmHandle); cardIns->mmapFlag = false; - ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); + int32_t ret = ResetCaptureParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!"); return ret; @@ -368,13 +359,12 @@ static int32_t SaveHwParams(struct AlsaSoundCard *cardIns, const struct AudioHwC int32_t CaptureSetParams(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData) { - int32_t ret; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(handleData); SaveHwParams(cardIns, handleData); - ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + int32_t ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret < 0) { AUDIO_FUNC_LOGE("Setting of hwparams failed."); return HDF_FAILURE; @@ -391,15 +381,14 @@ int32_t CaptureSetParams(struct AlsaCapture *captureIns, const struct AudioHwCap static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) { - int32_t ret; - int32_t i; + int32_t ret = HDF_SUCCESS; struct AlsaCapture *captureIns = NULL; struct AlsaSoundCard *alsaSnd = NULL; /* fine the instance with the corresponding adapter name, or create one if none. */ - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; if (alsaSnd->cardStatus) { if (0 == strcmp(alsaSnd->adapterName, adapterName)) { @@ -408,7 +397,7 @@ static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) } } - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { captureIns = &g_alsaCaptureList[i]; alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; if (alsaSnd->cardStatus == 0) { @@ -433,7 +422,6 @@ static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) struct AlsaCapture *CaptureCreateInstance(const char* adapterName) { - int32_t ret; struct AlsaCapture *captureIns = NULL; if (adapterName == NULL || strlen(adapterName) == 0) { AUDIO_FUNC_LOGE("Invalid adapterName!"); @@ -455,7 +443,7 @@ struct AlsaCapture *CaptureCreateInstance(const char* adapterName) } RegisterCaptureImpl(captureIns); - ret = SndSaveCardListInfo(SND_PCM_STREAM_CAPTURE); + int32_t ret = SndSaveCardListInfo(SND_PCM_STREAM_CAPTURE); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Failed to save card device info."); return NULL; @@ -474,8 +462,6 @@ struct AlsaCapture *CaptureCreateInstance(const char* adapterName) struct AlsaCapture *CaptureGetInstance(const char *adapterName) { - int32_t i; - if (adapterName == NULL || strlen(adapterName) == 0) { AUDIO_FUNC_LOGE("Invalid cardName!"); return NULL; @@ -486,7 +472,7 @@ struct AlsaCapture *CaptureGetInstance(const char *adapterName) return NULL; } - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { if (strcmp(g_alsaCaptureList[i].soundCard.adapterName, adapterName) == 0) { return &(g_alsaCaptureList[i]); } @@ -497,17 +483,15 @@ struct AlsaCapture *CaptureGetInstance(const char *adapterName) static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize) { - uint32_t capFrameSize; - uint64_t capReqBufferSize; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); CHECK_NULL_PTR_RETURN_DEFAULT(periodSize); - capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; + uint32_t capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; if (capFrameSize == 0) { AUDIO_FUNC_LOGE("Capture frame size is zero!"); return HDF_FAILURE; } - capReqBufferSize = capFrameSize * (*periodSize); + uint64_t capReqBufferSize = capFrameSize * (*periodSize); if (capReqBufferSize > FRAME_DATA) { *periodSize = FRAME_DATA / capFrameSize; } @@ -517,7 +501,7 @@ static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, s static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle) { - int32_t ret; + int32_t ret = HDF_SUCCESS; CHECK_NULL_PTR_RETURN_DEFAULT(capturePcmHandle); #ifndef EMULATOR_ENABLED ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */ @@ -594,10 +578,6 @@ static int32_t CapturePcmReadi(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames) { - int32_t ret; - uint32_t channels; - uint32_t format; - uint64_t recvDataSize; CHECK_NULL_PTR_RETURN_DEFAULT(handleData); CHECK_NULL_PTR_RETURN_DEFAULT(buffer); if (frames == 0) { @@ -609,10 +589,10 @@ static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buf AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!"); return HDF_FAILURE; } - channels = handleData->frameCaptureMode.attrs.channelCount; - format = (uint32_t)handleData->frameCaptureMode.attrs.format; - recvDataSize = (uint64_t)(frames * channels * format); - ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize); + uint32_t channels = handleData->frameCaptureMode.attrs.channelCount; + uint32_t format = (uint32_t)handleData->frameCaptureMode.attrs.format; + uint64_t recvDataSize = (uint64_t)(frames * channels * format); + int32_t ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize); if (ret != EOK) { AUDIO_FUNC_LOGE("memcpy frame data failed!"); return HDF_FAILURE; @@ -625,7 +605,6 @@ static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buf static int32_t CaptureOpenImpl(struct AlsaCapture *captureIns) { - int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); if (SndisBusy(&captureIns->soundCard)) { @@ -634,7 +613,7 @@ static int32_t CaptureOpenImpl(struct AlsaCapture *captureIns) return HDF_ERR_DEVICE_BUSY; } - ret = snd_pcm_open(&captureIns->soundCard.pcmHandle, captureIns->soundCard.devName, + int32_t ret = snd_pcm_open(&captureIns->soundCard.pcmHandle, captureIns->soundCard.devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); @@ -692,7 +671,6 @@ static int32_t CaptureCheckMmapMode(struct AlsaSoundCard *cardIns) static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCaptureParam *handleData) { - int32_t ret; uint64_t frames = 0; char *buffer = NULL; snd_pcm_uframes_t bufferSize = 0; @@ -706,7 +684,7 @@ static int32_t CaptureReadImpl(struct AlsaCapture *captureIns, struct AudioHwCap return HDF_FAILURE; } - ret = snd_pcm_get_params(cardIns->pcmHandle, &bufferSize, &periodSize); + int32_t ret = snd_pcm_get_params(cardIns->pcmHandle, &bufferSize, &periodSize); if (ret < 0) { AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -752,10 +730,6 @@ static int32_t CaptureGetMmapPositionImpl(struct AlsaCapture *captureIns) static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct AudioHwCaptureParam *handleData) { - char *mmapAddr; - uint32_t frameSize; - snd_pcm_sframes_t xfer; - snd_pcm_uframes_t size; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); CHECK_NULL_PTR_RETURN_DEFAULT(handleData); @@ -770,15 +744,15 @@ static int32_t CaptureMmapReadImpl(struct AlsaCapture *captureIns, const struct return HDF_FAILURE; } - mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; + char *mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress; if (mmapAddr == NULL) { AUDIO_FUNC_LOGE("mmapAddr is NULL!"); return HDF_FAILURE; } - size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames; - frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; + snd_pcm_uframes_t size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames; + uint32_t frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format; while (size > 0) { - xfer = snd_pcm_mmap_readi(cardIns->pcmHandle, mmapAddr, size); + snd_pcm_sframes_t xfer = snd_pcm_mmap_readi(cardIns->pcmHandle, mmapAddr, size); if (xfer < 0) { if (xfer == -EAGAIN) { snd_pcm_wait(cardIns->pcmHandle, AUDIO_PCM_WAIT); @@ -873,7 +847,7 @@ static int32_t CaptureSetMuteImpl(struct AlsaCapture *captureIns, bool muteFlag) static int32_t CaptureSetPauseStateImpl(struct AlsaCapture *captureIns, bool pauseFlag) { - int32_t ret; + int32_t ret = HDF_SUCCESS; int pause = pauseFlag ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index d952038db4..6c9db2c98e 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -86,13 +86,12 @@ static int32_t RenderFreeMemory(void) static int32_t SetHWParamsSub( snd_pcm_t *handle, snd_pcm_hw_params_t *params, const struct AudioPcmHwParams *hwParams, snd_pcm_access_t access) { - int32_t ret; snd_pcm_format_t pcmFormat = SND_PCM_FORMAT_S16_LE; CHECK_NULL_PTR_RETURN_DEFAULT(handle); CHECK_NULL_PTR_RETURN_DEFAULT(params); /* set hardware resampling,enable alsa-lib resampling */ - ret = snd_pcm_hw_params_set_rate_resample(handle, params, 1); + int32_t ret = snd_pcm_hw_params_set_rate_resample(handle, params, 1); if (ret < 0) { AUDIO_FUNC_LOGE("Resampling setup failed for playback: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -128,16 +127,14 @@ static int32_t SetHWParamsSub( static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_t *rate) { - int32_t ret; - uint32_t rRate; int dir = 0; /* dir Value range (-1,0,1) */ CHECK_NULL_PTR_RETURN_DEFAULT(handle); CHECK_NULL_PTR_RETURN_DEFAULT(params); CHECK_NULL_PTR_RETURN_DEFAULT(rate); /* set the stream rate */ - rRate = *rate; - ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); + uint32_t rRate = *rate; + int32_t ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir); if (ret < 0) { AUDIO_FUNC_LOGE("Rate %{public}uHz not available for playback: %{public}s.", *rate, snd_strerror(ret)); return HDF_FAILURE; @@ -211,7 +208,6 @@ static int32_t SetHWParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t acces static int32_t SetSWParams(struct AlsaSoundCard *cardIns) { - int32_t ret; snd_pcm_sw_params_t *swParams = NULL; snd_pcm_t *handle = cardIns->pcmHandle; struct AlsaRender *renderIns = (struct AlsaRender *)cardIns; @@ -220,7 +216,7 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) snd_pcm_sw_params_alloca(&swParams); /* get the current swparams */ - ret = snd_pcm_sw_params_current(handle, swParams); + int32_t ret = snd_pcm_sw_params_current(handle, swParams); if (ret < 0) { AUDIO_FUNC_LOGE("Unable to determine current swparams for playback: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -268,10 +264,9 @@ static int32_t SetSWParams(struct AlsaSoundCard *cardIns) static int32_t ResetRenderParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t access) { - int32_t ret; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); - ret = SetHWParams(cardIns, access); + int32_t ret = SetHWParams(cardIns, access); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Setting of hwparams failed."); return ret; @@ -288,15 +283,14 @@ static int32_t ResetRenderParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t static struct AlsaRender *GetRenderInsByName(const char *adapterName) { - int32_t ret; - int32_t i; + int32_t ret = HDF_SUCCESS; struct AlsaRender *renderIns = NULL; struct AlsaSoundCard *alsaSnd = NULL; /* fine the instance with the corresponding adapter name, or create one if none. */ - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; if (alsaSnd->cardStatus) { if (0 == strcmp(alsaSnd->adapterName, adapterName)) { @@ -305,7 +299,7 @@ static struct AlsaRender *GetRenderInsByName(const char *adapterName) } } - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { renderIns = &g_alsaRenderList[i]; alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; if (alsaSnd->cardStatus == 0) { @@ -330,14 +324,13 @@ static struct AlsaRender *GetRenderInsByName(const char *adapterName) struct AlsaRender *RenderCreateInstance(const char* adapterName) { - int32_t ret; struct AlsaRender *renderIns = NULL; if (adapterName == NULL || strlen(adapterName) == 0) { AUDIO_FUNC_LOGE("Invalid adapterName!"); return NULL; } - ret = CreateRenderIns(); + int32_t ret = CreateRenderIns(); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("Failed to create render instance."); return NULL; @@ -369,8 +362,6 @@ struct AlsaRender *RenderCreateInstance(const char* adapterName) struct AlsaRender *RenderGetInstance(const char *adapterName) { - int32_t i; - if (adapterName == NULL || strlen(adapterName) == 0) { AUDIO_FUNC_LOGE("Invalid adapterName!"); return NULL; @@ -381,7 +372,7 @@ struct AlsaRender *RenderGetInstance(const char *adapterName) return NULL; } - for (i = 0; i < MAX_CARD_NUM; i++) { + for (int32_t i = 0; i < MAX_CARD_NUM; i++) { if (strcmp(g_alsaRenderList[i].soundCard.adapterName, adapterName) == 0) { return &(g_alsaRenderList[i]); } @@ -528,15 +519,12 @@ static int32_t RenderHwParamsChmaps(struct AlsaSoundCard *cardIns) int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) { - int32_t ret; - int bitsPerSample; - snd_pcm_format_t fmt; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); CHECK_NULL_PTR_RETURN_DEFAULT(handleData); SaveHwParams(&renderIns->soundCard, handleData); - ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); + int32_t ret = SetHWParams(cardIns, SND_PCM_ACCESS_RW_INTERLEAVED); if (ret < 0) { AUDIO_FUNC_LOGE("Setting of hwparams failed."); return HDF_FAILURE; @@ -554,9 +542,9 @@ int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRender AUDIO_FUNC_LOGE("Setting of chmaps failed."); } #endif - + snd_pcm_format_t fmt; SndConverAlsaPcmFormat(&cardIns->hwParams, &fmt); - bitsPerSample = snd_pcm_format_physical_width(fmt); + int bitsPerSample = snd_pcm_format_physical_width(fmt); cardIns->hwParams.bitsPerFrame = bitsPerSample * cardIns->hwParams.channels; return HDF_SUCCESS; @@ -565,14 +553,12 @@ int32_t RenderSetParams(struct AlsaRender *renderIns, const struct AudioHwRender static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *handleData, const struct AudioPcmHwParams *hwParams) { - int32_t ret, offset; - char *dataBuf; - size_t sbufFrameSize; + int32_t ret = HDF_SUCCESS; snd_pcm_state_t state; int32_t tryNum = AUDIO_ALSALIB_RETYR; /* Check whether the PCM status is normal */ - state = snd_pcm_state(pcm); + snd_pcm_state_t state = snd_pcm_state(pcm); if (state == SND_PCM_STATE_SETUP) { ret = snd_pcm_prepare(pcm); if (ret < 0) { @@ -581,9 +567,9 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han } } - sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; - dataBuf = handleData->frameRenderMode.buffer; - offset = hwParams->bitsPerFrame / BIT_COUNT_OF_BYTE; + size_t sbufFrameSize = (size_t)handleData->frameRenderMode.bufferFrameSize; + char *dataBuf = handleData->frameRenderMode.buffer; + int32_t offset = hwParams->bitsPerFrame / BIT_COUNT_OF_BYTE; while (sbufFrameSize > 0) { long frames = snd_pcm_writei(pcm, dataBuf, sbufFrameSize); if (frames > 0) { @@ -619,10 +605,6 @@ static int32_t RenderWritei(snd_pcm_t *pcm, const struct AudioHwRenderParam *han static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct AudioHwRenderParam *handleData) { - uint32_t frameSize; - uint32_t totalSize; - uint32_t lastBuffSize; - uint32_t loopTimes; uint32_t looper = 0; int32_t count = 0; struct AudioMmapBufferDescriptor *mmapBufDesc = NULL; @@ -636,15 +618,15 @@ static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct Audi return HDF_FAILURE; } - frameSize = cardIns->hwParams.channels * cardIns->hwParams.format; + uint32_t frameSize = cardIns->hwParams.channels * cardIns->hwParams.format; if (frameSize == 0) { AUDIO_FUNC_LOGE("frame size = 0!"); return HDF_FAILURE; } mmapBufDesc = (struct AudioMmapBufferDescriptor *)&(handleData->frameRenderMode.mmapBufDesc); - totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; - lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); - loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + uint32_t totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; + uint32_t lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); + uint32_t loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); while (looper < loopTimes) { uint32_t copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); @@ -673,7 +655,6 @@ static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct Audi static int32_t RenderOpenImpl(struct AlsaRender *renderIns) { - int32_t ret; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); @@ -682,7 +663,7 @@ static int32_t RenderOpenImpl(struct AlsaRender *renderIns) return HDF_ERR_DEVICE_BUSY; } - ret = snd_pcm_open(&cardIns->pcmHandle, cardIns->devName, + int32_t ret = snd_pcm_open(&cardIns->pcmHandle, cardIns->devName, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_open fail: %{public}s!", snd_strerror(ret)); @@ -722,7 +703,7 @@ static int32_t RenderCloseImpl(struct AlsaRender *renderIns) int32_t RenderWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) { - int32_t ret; + int32_t ret = HDF_SUCCESS; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard*)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); @@ -756,7 +737,6 @@ int32_t RenderGetMmapPositionImpl(struct AlsaRender *renderIns) int32_t RenderMmapWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRenderParam *handleData) { - int32_t ret; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); CHECK_NULL_PTR_RETURN_DEFAULT(handleData); @@ -767,7 +747,7 @@ int32_t RenderMmapWriteImpl(struct AlsaRender *renderIns, const struct AudioHwRe } cardIns->mmapFlag = false; - ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); + int32_t ret = ResetRenderParams(cardIns, SND_PCM_ACCESS_MMAP_INTERLEAVED); if (ret < 0) { AUDIO_FUNC_LOGE("ResetRenderParams failed!"); return HDF_FAILURE; diff --git a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c index 947166c4d5..299a5c4bc0 100644 --- a/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_soundcard.c @@ -51,7 +51,6 @@ static struct AlsaCardsList g_alsaCardsDevList; static char *CfgReadAdapterFile(const char *fpath) { - int32_t jsonStrSize; FILE *fp = NULL; char *pJsonStr = NULL; char pathBuf[PATH_MAX] = {0}; @@ -75,7 +74,7 @@ static char *CfgReadAdapterFile(const char *fpath) (void)fclose(fp); return NULL; } - jsonStrSize = ftell(fp); + int32_t jsonStrSize = ftell(fp); if (jsonStrSize <= 0) { AUDIO_FUNC_LOGE("The configuration file size <= 0!"); (void)fclose(fp); @@ -153,7 +152,6 @@ static int CfgGetAdapterInfo(const char* adapterName, struct AlsaAdapterCfgInfo static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) { - int32_t ret, idx; enum SndCardType cardType = SND_CARD_UNKNOWN; CHECK_NULL_PTR_RETURN_DEFAULT(info); @@ -171,8 +169,8 @@ static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) AUDIO_FUNC_LOGE("Error: %{public}s is unspupported adapter name", info->adapterName); } - idx = g_alsaAdapterList[cardType].num; - ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), + int32_t idx = g_alsaAdapterList[cardType].num; + int32_t ret = memcpy_s((void*)&g_alsaAdapterList[cardType].list[idx], sizeof(struct AlsaAdapterCfgInfo), (void*)info, sizeof(struct AlsaAdapterCfgInfo)); if (ret != EOK) { AUDIO_FUNC_LOGE("memcpy_s g_alsaAdapterList fail!"); @@ -189,17 +187,15 @@ static int32_t CfgDumpAdapterInfo(struct AlsaAdapterCfgInfo *info) static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *info) { - int32_t ret; - cJSON *item; CHECK_NULL_PTR_RETURN_DEFAULT(adapter); CHECK_NULL_PTR_RETURN_DEFAULT(info); - item = cJSON_GetObjectItem(adapter, "name"); + cJSON *item = cJSON_GetObjectItem(adapter, "name"); if (item == NULL || item->valuestring == NULL) { AUDIO_FUNC_LOGE("adapter name is null!"); return HDF_FAILURE; } - ret = memcpy_s(info->adapterName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); + int32_t ret = memcpy_s(info->adapterName, MAX_CARD_NAME_LEN - 1, item->valuestring, MAX_CARD_NAME_LEN - 1); if (ret != EOK) { AUDIO_FUNC_LOGE("memcpy_s adapterName fail!"); return HDF_FAILURE; @@ -228,7 +224,6 @@ static int32_t CfgSaveAdapterStruct(cJSON *adapter, struct AlsaAdapterCfgInfo *i static int32_t CfgParseAdapterItems(cJSON *adapterObj) { - int32_t adapterNum; cJSON *adapterItems = NULL; adapterItems = cJSON_GetObjectItem(adapterObj, "adapters"); @@ -236,7 +231,7 @@ static int32_t CfgParseAdapterItems(cJSON *adapterObj) AUDIO_FUNC_LOGE("Get adapterItems from json failed!\n"); return HDF_FAILURE; } - adapterNum = cJSON_GetArraySize(adapterItems); + int32_t adapterNum = cJSON_GetArraySize(adapterItems); if (adapterNum <= 0) { AUDIO_FUNC_LOGE("Get adapter number failed!"); return HDF_FAILURE; @@ -271,7 +266,6 @@ static int32_t CfgParseAdapterItems(cJSON *adapterObj) int32_t CfgSaveAdapterFromFile(void) { - int32_t ret; cJSON *adapterObj = NULL; char *configBuf = NULL; @@ -288,7 +282,7 @@ int32_t CfgSaveAdapterFromFile(void) } AudioMemFree((void **)&configBuf); - ret = CfgParseAdapterItems(adapterObj); + int32_t ret = CfgParseAdapterItems(adapterObj); if (ret != HDF_SUCCESS) { cJSON_Delete(adapterObj); AUDIO_FUNC_LOGE("Parse adapter items failed!"); @@ -382,12 +376,11 @@ static int32_t DevSaveCardPcmInfo(snd_ctl_t *handle, snd_pcm_stream_t stream, in static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) { - int32_t ret; - snd_ctl_t *handle; + snd_ctl_t *handle = NULL; int card = -1; char deviceName[MAX_CARD_NAME_LEN] = {0}; - ret = snd_card_next(&card); + int32_t ret = snd_card_next(&card); if (ret < 0 || card < 0) { AUDIO_FUNC_LOGE("No soundcards found: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -431,15 +424,13 @@ static int32_t DevSaveDriverInfo(snd_pcm_stream_t stream) int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) { - int32_t ret; - (void)memset_s(&g_alsaAdapterList, sizeof(struct AlsaAdapterList) * SND_CARD_MAX, 0, sizeof(struct AlsaAdapterList) * SND_CARD_MAX); (void)memset_s(&g_alsaCardsDevList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList)); /* Parse sound card from configuration file */ - ret = CfgSaveAdapterFromFile(); + int32_t ret = CfgSaveAdapterFromFile(); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("parse config file failed! ret = %{public}d", ret); return HDF_FAILURE; @@ -469,13 +460,11 @@ int32_t SndSaveCardListInfo(snd_pcm_stream_t stream) int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterName) { - int32_t ret; - enum SndCardType cardType; struct AlsaDevInfo *devInfo = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(adapterName); - cardType = CfgGetAdapterCardType(adapterName); + enum SndCardType cardType = CfgGetAdapterCardType(adapterName); if (cardType == SND_CARD_UNKNOWN) { AUDIO_FUNC_LOGE("unknow card type error."); return HDF_FAILURE; @@ -495,7 +484,7 @@ int32_t SndMatchSelAdapter(struct AlsaSoundCard *cardIns, const char *adapterNam return HDF_FAILURE; } - ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, + int32_t ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d,%d", devInfo->card, devInfo->device); if (ret < 0) { AUDIO_FUNC_LOGE("%{public}s snprintf_s devName failed", cardIns->adapterName); @@ -567,8 +556,7 @@ int32_t SndConverAlsaPcmFormat(const struct AudioPcmHwParams *hwParams, snd_pcm_ int32_t SndPcmPrepare(struct AlsaSoundCard *cardIns) { CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); - int32_t ret; - ret = snd_pcm_prepare(cardIns->pcmHandle); + int32_t ret = snd_pcm_prepare(cardIns->pcmHandle); if (ret < 0) { AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -587,14 +575,13 @@ bool SndisBusy(struct AlsaSoundCard *cardIns) int32_t SndOpenMixer(struct AlsaSoundCard *cardIns) { CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); - int32_t ret; if (strlen(cardIns->ctrlName) == 0) { AUDIO_FUNC_LOGE("The soundcard ctrname is null."); return HDF_FAILURE; } - ret = snd_mixer_open(&cardIns->mixerHandle, 0); + int32_t ret = snd_mixer_open(&cardIns->mixerHandle, 0); if (ret < 0) { AUDIO_FUNC_LOGE("Failed to open mixer: %{public}s.", snd_strerror(ret)); return HDF_FAILURE; @@ -693,7 +680,7 @@ static void AudioInitPortOutAndIn(struct AudioPort *audioPort) static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardType type) { - uint8_t portNum; + uint8_t portNum = 0; CHECK_NULL_PTR_RETURN_DEFAULT(desc); switch (type) { @@ -742,17 +729,15 @@ static int32_t AudioInitPorts(struct AudioAdapterDescriptor *desc, enum SndCardT int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndCardNum) { - int32_t ret, idx; - int32_t adapterNum; CHECK_NULL_PTR_RETURN_DEFAULT(descs); CHECK_NULL_PTR_RETURN_DEFAULT(sndCardNum); - ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); + int32_t ret = SndSaveCardListInfo(SND_PCM_STREAM_PLAYBACK); if (ret != HDF_SUCCESS) { return HDF_FAILURE; } - adapterNum = CfgGetAdapterCount(); + int32_t adapterNum = CfgGetAdapterCount(); if (*descs == NULL) { AUDIO_FUNC_LOGW("*descs is null, need memcalloc."); *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * adapterNum); @@ -763,7 +748,7 @@ int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndC } *sndCardNum = adapterNum; - idx = 0; + int32_t idx = 0; for (enum SndCardType type = SND_CARD_PRIMARY; type < SND_CARD_MAX; ++type) { for (int32_t i = 0; i < g_alsaAdapterList[type].num; ++i) { (*descs)[idx].adapterName = strdup(g_alsaAdapterList[type].list[i].adapterName); @@ -850,8 +835,6 @@ static snd_ctl_elem_iface_t ConvertIfaceType(enum SndIfaceType iface) static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlElement *ctlElem, snd_ctl_elem_info_t *info, snd_ctl_elem_id_t *id) { - int32_t ret; - snd_ctl_elem_iface_t ifaceType; CHECK_NULL_PTR_RETURN_DEFAULT(alsaHandle); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); CHECK_NULL_PTR_RETURN_DEFAULT(info); @@ -870,13 +853,13 @@ static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlEl snd_ctl_elem_id_set_subdevice(id, ctlElem->subdevice); } - ifaceType = ConvertIfaceType(ctlElem->iface); + snd_ctl_elem_iface_t ifaceType = ConvertIfaceType(ctlElem->iface); snd_ctl_elem_id_set_interface(id, ifaceType); if (ctlElem->name) { snd_ctl_elem_id_set_name(id, ctlElem->name); } snd_ctl_elem_info_set_id(info, id); - ret = snd_ctl_elem_info(alsaHandle, info); + int32_t ret = snd_ctl_elem_info(alsaHandle, info); if (ret < 0) { AUDIO_FUNC_LOGE("Cannot find the given element from elem_value\n"); return HDF_FAILURE; @@ -889,17 +872,15 @@ static int32_t SetElementInfo(snd_ctl_t *alsaHandle, const struct AlsaMixerCtlEl int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long *value) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -925,7 +906,7 @@ int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, return HDF_FAILURE; } - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_INTEGER) { *value = snd_ctl_elem_value_get_integer(elem_value, 0); } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { @@ -941,17 +922,15 @@ int32_t SndElementReadInt(struct AlsaSoundCard *cardIns, int32_t SndElementReadEnum( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int *item) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -977,7 +956,7 @@ int32_t SndElementReadEnum( return HDF_FAILURE; } - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_ENUMERATED) { *item = snd_ctl_elem_value_get_enumerated(elem_value, 0); } else { @@ -991,17 +970,15 @@ int32_t SndElementReadEnum( int32_t SndElementReadRange( struct AlsaSoundCard * cardIns, const struct AlsaMixerCtlElement * ctlElem, long * mix, long * max) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1027,7 +1004,7 @@ int32_t SndElementReadRange( return HDF_FAILURE; } - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_INTEGER) { *mix = snd_ctl_elem_info_get_min(elem_info); *max = snd_ctl_elem_info_get_max(elem_info); @@ -1045,17 +1022,15 @@ int32_t SndElementReadRange( int32_t SndElementReadSwitch( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool *on) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1081,7 +1056,7 @@ int32_t SndElementReadSwitch( return HDF_FAILURE; } - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_BOOLEAN) { ret = snd_ctl_elem_value_get_boolean(elem_value, 0); *on = (ret > 0) ? true : false; @@ -1096,17 +1071,15 @@ int32_t SndElementReadSwitch( int32_t SndElementWriteInt( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, long value) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1127,7 +1100,7 @@ int32_t SndElementWriteInt( } snd_ctl_elem_value_set_id(elem_value, elem_id); - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_INTEGER) { snd_ctl_elem_value_set_integer(elem_value, 0, value); } else if (type == SND_CTL_ELEM_TYPE_INTEGER64) { @@ -1149,17 +1122,15 @@ int32_t SndElementWriteInt( int32_t SndElementWriteEnum( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, unsigned int item) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1180,7 +1151,7 @@ int32_t SndElementWriteEnum( } snd_ctl_elem_value_set_id(elem_value, elem_id); - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_ENUMERATED) { snd_ctl_elem_value_set_enumerated(elem_value, 0, item); } else { @@ -1200,17 +1171,15 @@ int32_t SndElementWriteEnum( int32_t SndElementWriteSwitch( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem, bool on) { - int ret; snd_ctl_t *alsaHandle = NULL; snd_ctl_elem_id_t *elem_id; snd_ctl_elem_info_t *elem_info; snd_ctl_elem_value_t *elem_value; - snd_ctl_elem_type_t type; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1231,7 +1200,7 @@ int32_t SndElementWriteSwitch( } snd_ctl_elem_value_set_id(elem_value, elem_id); - type = snd_ctl_elem_info_get_type(elem_info); + snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(elem_info); if (type == SND_CTL_ELEM_TYPE_BOOLEAN) { int value = on ? 1 : 0; snd_ctl_elem_value_set_boolean(elem_value, 0, value); @@ -1252,16 +1221,15 @@ int32_t SndElementWriteSwitch( int32_t SndElementWrite( struct AlsaSoundCard *cardIns, const struct AlsaMixerCtlElement *ctlElem) { - int ret; snd_ctl_t *alsaHandle = NULL; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; - snd_ctl_elem_value_t *elem_value; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; + snd_ctl_elem_value_t *elem_value = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(ctlElem); - ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); + int ret = snd_ctl_open(&alsaHandle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("snd_ctl_open error: %{public}s", snd_strerror(ret)); return HDF_FAILURE; @@ -1314,15 +1282,14 @@ int32_t SndElementGroupWrite( int32_t SndTraversalMixerElement(struct AlsaSoundCard *cardIns, bool (*callback)(void *data, snd_ctl_elem_id_t *elem_id), void *data) { - int ret; - snd_hctl_t *handle; - snd_hctl_elem_t *elem; - snd_ctl_elem_id_t *elem_id; - snd_ctl_elem_info_t *elem_info; + snd_hctl_t *handle = NULL; + snd_hctl_elem_t *elem = NULL; + snd_ctl_elem_id_t *elem_id = NULL; + snd_ctl_elem_info_t *elem_info = NULL; CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(callback); - ret = snd_hctl_open(&handle, cardIns->ctrlName, 0); + int ret = snd_hctl_open(&handle, cardIns->ctrlName, 0); if (ret < 0) { AUDIO_FUNC_LOGE("Control %{public}s open error: %{public}s", cardIns->ctrlName, snd_strerror(ret)); -- Gitee From 479e768269083c4513a357d93e6e7034bcc7229a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 10:08:35 +0000 Subject: [PATCH 0037/1485] update audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index e2aa36472c..3b99c71e2b 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -539,7 +539,7 @@ static int32_t CapturePcmReadi(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf } do { - int32_t ret; + int32_t ret = HDF_SUCCESS; /* Read interleaved frames to a PCM. */ long frames = snd_pcm_readi(pcm, dataBuf, bufSize); if (frames > 0) { -- Gitee From 2f8413be2d6e07d2b75dbf10f2a8886ee514d9b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 10:49:46 +0000 Subject: [PATCH 0038/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- .../primary_impl/vdi_src/audio_render_vdi.c | 52 ++++++------------- 1 file changed, 17 insertions(+), 35 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 3ebf93cc66..6ad890775e 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -670,39 +670,26 @@ int32_t AudioRenderGetMmapPositionVdi(struct IAudioRender *render, uint64_t *fra int32_t AudioRenderAddAudioEffectVdi(struct IAudioRender *render, uint64_t effectid) { - CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM); - - struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render; - struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; - CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiRender->AddAudioEffect, HDF_ERR_INVALID_PARAM); - - return vdiRender->AddAudioEffect(vdiRender, effectid); + (void)render; + (void)effectid; + AUDIO_FUNC_LOGE("AddAudioEffect not support"); + return HDF_ERR_NOT_SUPPORT; } int32_t AudioRenderRemoveAudioEffectVdi(struct IAudioRender *render, uint64_t effectid) { - CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM); - - struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render; - struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; - CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiRender->RemoveAudioEffect, HDF_ERR_INVALID_PARAM); - - return vdiRender->RemoveAudioEffect(vdiRender, effectid); + (void)render; + (void)effectid; + AUDIO_FUNC_LOGE("RemoveAudioEffect not support"); + return HDF_ERR_NOT_SUPPORT; } int32_t AudioRenderGetFrameBufferSizeVdi(struct IAudioRender *render, uint64_t *bufferSize) { - CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(bufferSize, HDF_ERR_INVALID_PARAM); - - struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render; - struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; - CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetFrameBufferSize, HDF_ERR_INVALID_PARAM); - - return vdiRender->GetFrameBufferSize(vdiRender, bufferSize); + (void)render; + (void)bufferSize; + AUDIO_FUNC_LOGE("GetFrameBufferSize not support"); + return HDF_ERR_NOT_SUPPORT; } int32_t AudioRenderStartVdi(struct IAudioRender *render) @@ -833,16 +820,11 @@ int32_t AudioRenderAudioDevDumpVdi(struct IAudioRender *render, int32_t range, i int32_t AudioRenderIsSupportsPauseAndResumeVdi(struct IAudioRender *render, bool *supportPause, bool *supportResume) { - CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(supportPause, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(supportResume, HDF_ERR_INVALID_PARAM); - - struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render; - struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; - CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiRender->IsSupportsPauseAndResume, HDF_ERR_INVALID_PARAM); - - return vdiRender->IsSupportsPauseAndResume(vdiRender, supportPause, supportResume); + (void)render; + (void)supportPause; + (void)supportResume; + AUDIO_FUNC_LOGE("IsSupportsPauseAndResume not support"); + return HDF_ERR_NOT_SUPPORT; } int32_t AudioRenderSetbufferSize(struct IAudioRender *render, uint32_t size) -- Gitee From 4c4e6696b3fbbd3e3fb1b1f7026b32877923f297 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Fri, 2 Aug 2024 10:50:18 +0000 Subject: [PATCH 0039/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index 3675978481..d3f8e96046 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -144,10 +144,6 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe pthread_mutex_unlock(&g_adapterMutex); return HDF_FAILURE; } - vdiRender->AddAudioEffect = NULL; - vdiRender->RemoveAudioEffect = NULL; - vdiRender->GetFrameBufferSize = NULL; - vdiRender->IsSupportsPauseAndResume = NULL; *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc); if (*render == NULL) { (void)vdiAdapter->DestroyRender(vdiAdapter, vdiRender); -- Gitee From a8ad3fcf5d333c618d7d463e32ee821530e3b899 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 3 Aug 2024 01:03:56 +0000 Subject: [PATCH 0040/1485] update usb/gadget/function/include/data_fifo.h. Signed-off-by: luzhiye --- usb/gadget/function/include/data_fifo.h | 1 + 1 file changed, 1 insertion(+) diff --git a/usb/gadget/function/include/data_fifo.h b/usb/gadget/function/include/data_fifo.h index b64c904d41..61749510dc 100644 --- a/usb/gadget/function/include/data_fifo.h +++ b/usb/gadget/function/include/data_fifo.h @@ -17,6 +17,7 @@ #define HDF_USB_DATA_FIFO_H #include "hdf_base.h" +#include "hdf_log.h" #ifndef MIN #define MIN(a, b) ((a) < (b) ? (a) : (b)) -- Gitee From 46cdc161ea02dc4f5dbde7baed4807d54d9238c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Sat, 3 Aug 2024 03:05:04 +0000 Subject: [PATCH 0041/1485] update audio/supportlibs/alsa_adapter/src/alsa_snd_render.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/supportlibs/alsa_adapter/src/alsa_snd_render.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index 6c9db2c98e..929e3b05cd 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -626,7 +626,8 @@ static int32_t RenderWriteiMmap(struct AlsaSoundCard *cardIns, const struct Audi mmapBufDesc = (struct AudioMmapBufferDescriptor *)&(handleData->frameRenderMode.mmapBufDesc); uint32_t totalSize = (uint32_t)mmapBufDesc->totalBufferFrames * frameSize; uint32_t lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); - uint32_t loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + uint32_t loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? + (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); while (looper < loopTimes) { uint32_t copyLen = (looper < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; snd_pcm_uframes_t frames = (snd_pcm_uframes_t)(copyLen / frameSize); -- Gitee From 1a3351586405c3d38c7cc53caf714a1456f85dfa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Sat, 3 Aug 2024 03:28:09 +0000 Subject: [PATCH 0042/1485] update audio/hdi_service/primary_impl/src/audio_render.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/src/audio_render.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/audio/hdi_service/primary_impl/src/audio_render.c b/audio/hdi_service/primary_impl/src/audio_render.c index 6a325009c1..af00ed2ddf 100644 --- a/audio/hdi_service/primary_impl/src/audio_render.c +++ b/audio/hdi_service/primary_impl/src/audio_render.c @@ -839,17 +839,16 @@ int32_t AudioRenderRenderFrame( AUDIO_FUNC_LOGE("Render Frame Paras is NULL!"); return AUDIO_ERR_INVALID_PARAM; } + if (frameLen > FRAME_DATA) { + AUDIO_FUNC_LOGE("Out of FRAME_DATA size!"); + return AUDIO_ERR_INTERNAL; + } pthread_mutex_lock(&hwRender->renderParam.frameRenderMode.mutex); if (hwRender->renderParam.frameRenderMode.buffer == NULL) { pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); AUDIO_FUNC_LOGE("Render Frame buffer is NULL!"); return AUDIO_ERR_INVALID_PARAM; } - if (frameLen > FRAME_DATA) { - pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); - AUDIO_FUNC_LOGE("Out of FRAME_DATA size!"); - return AUDIO_ERR_INTERNAL; - } int32_t ret = memcpy_s(hwRender->renderParam.frameRenderMode.buffer, FRAME_DATA, frame, frameLen); if (ret != EOK) { @@ -860,11 +859,10 @@ int32_t AudioRenderRenderFrame( hwRender->renderParam.frameRenderMode.bufferSize = (uint64_t)frameLen; uint32_t frameCount = 0; - ret = PcmBytesToFrames(&hwRender->renderParam.frameRenderMode, (uint64_t)frameLen, &frameCount); - if (ret != AUDIO_SUCCESS) { + if (PcmBytesToFrames(&hwRender->renderParam.frameRenderMode, (uint64_t)frameLen, &frameCount) != AUDIO_SUCCESS) { pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex); AUDIO_FUNC_LOGE("PcmBytesToFrames error!"); - return ret; + return AUDIO_ERR_INTERNAL; } hwRender->renderParam.frameRenderMode.bufferFrameSize = (uint64_t)frameCount; -- Gitee From 3b0d498be701487905d9d58026aab6dbf3116332 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Sat, 3 Aug 2024 06:37:04 +0000 Subject: [PATCH 0043/1485] move free submitRequest->urbs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/src/usb_io_manage.c | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/ddk/host/src/usb_io_manage.c b/usb/ddk/host/src/usb_io_manage.c index 53d11b5d90..1d2031b958 100644 --- a/usb/ddk/host/src/usb_io_manage.c +++ b/usb/ddk/host/src/usb_io_manage.c @@ -92,7 +92,6 @@ static int32_t IoSendProcess(const void *interfacePoolArg) HDF_LOGE("%{public}s:%{public}d submit request failed", __func__, __LINE__); submitRequest->status = USB_REQUEST_ERROR; UsbIoSetRequestCompletionInfo(submitRequest); - RawUsbMemFree(submitRequest->urbs); continue; } } -- Gitee From d1b9eebac49a9eedf309f907c2de1d4c6d685b5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=83=A1=E7=85=9C?= Date: Sat, 3 Aug 2024 11:57:21 +0800 Subject: [PATCH 0044/1485] =?UTF-8?q?wpa=20host=20crash=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 胡煜 --- wlan/wpa/client/include/wpa_client.h | 2 +- wlan/wpa/client/src/wpa_client.c | 15 ++++++ .../service_common/hdi_wpa_common.c | 46 ++++++++++++++++--- .../service_common/hdi_wpa_common.h | 4 ++ .../hdi_service/service_common/hdi_wpa_hal.c | 24 ++++++++++ .../hdi_service/service_common/hdi_wpa_hal.h | 2 + .../service_common/wpa_common_cmd.c | 26 ++++++----- 7 files changed, 100 insertions(+), 19 deletions(-) diff --git a/wlan/wpa/client/include/wpa_client.h b/wlan/wpa/client/include/wpa_client.h index 3df0f8e935..17978a7fc2 100644 --- a/wlan/wpa/client/include/wpa_client.h +++ b/wlan/wpa/client/include/wpa_client.h @@ -244,5 +244,5 @@ struct WpaVendorExtInfo { void WpaEventReport(const char *ifName, uint32_t event, void *data); int32_t WpaRegisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName); int32_t WpaUnregisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName); - +void ReleaseEventCallback(void); #endif diff --git a/wlan/wpa/client/src/wpa_client.c b/wlan/wpa/client/src/wpa_client.c index de06e3ae4b..c32ce54b7f 100644 --- a/wlan/wpa/client/src/wpa_client.c +++ b/wlan/wpa/client/src/wpa_client.c @@ -107,6 +107,21 @@ int32_t WpaUnregisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, return HDF_FAILURE; } +void ReleaseEventCallback(void) +{ + pthread_mutex_lock(&g_wpaCallbackMutex); + for (uint32_t i = 0; i < MAX_CALL_BACK_COUNT; i++) { + if (g_wpaCallbackEventMap[i] != NULL && + (strncmp(g_wpaCallbackEventMap[i]->ifName, "chba", strlen("chba")) == 0)) { + g_wpaCallbackEventMap[i]->onRecFunc = NULL; + free(g_wpaCallbackEventMap[i]); + g_wpaCallbackEventMap[i] = NULL; + break; + } + } + pthread_mutex_unlock(&g_wpaCallbackMutex); +} + void WpaEventReport(const char *ifName, uint32_t event, void *data) { uint32_t i; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index c459f13251..1f118d7675 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -31,6 +31,7 @@ static pthread_mutex_t g_mutexSta; static pthread_mutex_t g_mutexP2p; static pthread_mutex_t g_mutexChba; static pthread_mutex_t g_mutexCommon; +static pthread_mutex_t g_mutexWpa; int Hex2Dec(const char *str) { @@ -254,12 +255,14 @@ static int CommonCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) { + int ret = -1; HDF_LOGI("enter WpaCliCmd"); if (cmd == NULL || buf == NULL || bufLen == 0) { HDF_LOGE("WpaCliCmd, invalid parameters!"); - return -1; + return ret; } char *ifName = NULL; + pthread_mutex_lock(&g_mutexWpa); if (strncmp(cmd, "IFNAME=", strlen("IFNAME=")) == 0) { ifName = (char *)cmd + strlen("IFNAME="); } else if (strncmp(cmd, "INTERFACE_ADD ", strlen("INTERFACE_ADD ")) == 0) { @@ -271,15 +274,46 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) } if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - return StaCliCmd(GetStaCtrl(), cmd, buf, bufLen); + ret = StaCliCmd(GetStaCtrl(), cmd, buf, bufLen); } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { - return P2pCliCmd(GetP2pCtrl(), cmd, buf, bufLen); + ret = P2pCliCmd(GetP2pCtrl(), cmd, buf, bufLen); } else if (strncmp(ifName, "chba", strlen("chba")) == 0) { - return ChbaCliCmd(GetChbaCtrl(), cmd, buf, bufLen); + ret = ChbaCliCmd(GetChbaCtrl(), cmd, buf, bufLen); } else if (strncmp(ifName, "common", strlen("common")) == 0) { - return CommonCliCmd(GetCommonCtrl(), cmd, buf, bufLen); + ret = CommonCliCmd(GetCommonCtrl(), cmd, buf, bufLen); } else { HDF_LOGE("WpaCliCmd, ifName is unknow!"); - return -1; } + if (ret == 0 && ifName != NULL && + strncmp(cmd, "INTERFACE_REMOVE ", strlen("INTERFACE_REMOVE ")) == 0) { + int nameLen = strlen(ifName); + ReleaseIfaceCtrl(ifName, nameLen); + } + pthread_mutex_unlock(&g_mutexWpa); + return ret; +} + +int IsSockRemoved(const char *ifName, int len) +{ + int ret = -1; + if (len < IFNAME_LEN_MIN || len > IFNAME_LEN_MAX) { + HDF_LOGE("ifname is invalid"); + return ret; + } + pthread_mutex_lock(&g_mutexWpa); + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + if (GetStaCtrl() == NULL) { + ret = 0; + } + } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { + if (GetP2pCtrl() == NULL) { + ret = 0; + } + } else if (strncmp(ifName, "chba", strlen("chba")) == 0) { + if (GetChbaCtrl() == NULL) { + ret = 0; + } + } + pthread_mutex_unlock(&g_mutexWpa); + return ret; } diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h index ab1f67ac36..9586527bd8 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h @@ -17,6 +17,7 @@ #include #include +#include #ifdef __cplusplus extern "C" { @@ -24,6 +25,8 @@ extern "C" { #define WPA_MESSAGE_KEY_LENGTH 64 #define WPA_MESSAGE_VALUE_LENGTH 256 +#define IFNAME_LEN_MIN 3 +#define IFNAME_LEN_MAX 15 typedef struct StWpaCtrl { struct wpa_ctrl *pSend; @@ -42,6 +45,7 @@ void ReleaseWpaCtrl(WpaCtrl *pCtrl); int WpaCliCmd(const char *cmd, char *buf, size_t bufLen); int Hex2Dec(const char *str); void TrimQuotationMark(char *str, char c); +int IsSockRemoved(const char *ifName, int len); #ifdef __cplusplus } diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index 957679577a..de72f1c2cc 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -21,6 +21,9 @@ #include "hdi_wpa_hal.h" #include "hdi_wpa_common.h" #include "wpa_common_cmd.h" +#ifndef OHOS_EUPDATER +#include "wpa_client.h" +#endif #undef LOG_TAG #define LOG_TAG "HdiWpaHal" @@ -293,3 +296,24 @@ WpaCtrl *GetCommonCtrl(void) } return &g_wpaInterface->commonCtrl; } + +void ReleaseIfaceCtrl(char *ifName, int len) +{ + if (g_wpaInterface == NULL) { + return; + } + if (len < IFNAME_LEN_MIN || len > IFNAME_LEN_MAX) { + HDF_LOGE("ifname is invalid"); + return; + } + if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { + ReleaseWpaCtrl(&(g_wpaInterface->p2pCtrl)); + } + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + ReleaseWpaCtrl(&(g_wpaInterface->staCtrl)); + ReleaseWpaCtrl(&(g_wpaInterface->chbaCtrl)); +#ifndef OHOS_EUPDATER + ReleaseEventCallback(); +#endif + } +} diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h index a3b33c9eb8..794e58e7c0 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h @@ -64,6 +64,8 @@ WpaCtrl *GetStaCtrl(void); WpaCtrl *GetP2pCtrl(void); WpaCtrl *GetChbaCtrl(void); WpaCtrl *GetCommonCtrl(void); +void ReleaseIfaceCtrl(char *ifName, int len); + #ifdef __cplusplus } #endif diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 7646da001c..143e818266 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -1853,6 +1853,11 @@ int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWp HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + int nameLen = strlen(ifName); + if (IsSockRemoved(ifName, nameLen) == 0) { + HDF_LOGE("invalid opt"); + return HDF_FAILURE; + } (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); do { HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); @@ -1969,6 +1974,15 @@ static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) pthread_setname_np(g_tid, "WpaMainThread"); HDF_LOGI("%{public}s: pthread_create successfully.", __func__); usleep(WPA_SLEEP_TIME); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + return HDF_FAILURE; + } + if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { + HDF_LOGE("Failed to connect to wpa!"); + return HDF_FAILURE; + } return HDF_SUCCESS; } int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) @@ -1985,10 +1999,6 @@ int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, HDF_LOGE("Get wpa interface failed!"); return HDF_FAILURE; } - if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { - HDF_LOGE("Failed to connect to wpa!"); - return HDF_FAILURE; - } AddInterfaceArgv addInterface = {0}; if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || @@ -2036,14 +2046,6 @@ int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifNam } ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); - if (ret == 0) { - if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { - ReleaseWpaCtrl(&(pWpaInterface->p2pCtrl)); - } - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - ReleaseWpaCtrl(&(pWpaInterface->staCtrl)); - } - } return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); } -- Gitee From a69476a3127b3f3e94ab77d8a2662daba9f08553 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Mon, 5 Aug 2024 01:06:57 +0000 Subject: [PATCH 0045/1485] delete useless backspace MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/hdi_service/src/usb_impl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 6f46c7a9c7..d56cf83c15 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1643,7 +1643,7 @@ int32_t UsbImpl::ControlTransferReadwithLength( controlParams.value = ctrlParams.value; controlParams.index = ctrlParams.index; controlParams.target = (UsbRequestTargetType)(static_cast(ctrlParams.requestType) & USB_RECIP_MASK); - controlParams.directon = (UsbRequestDirection)(((static_cast(ctrlParams.requestType)) + controlParams.directon = (UsbRequestDirection)(((static_cast(ctrlParams.requestType)) >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK); controlParams.reqType = static_cast(ctrlParams.requestType); controlParams.size = ctrlParams.length; -- Gitee From 468c88aeb4e3872779318d46cf8c75c4c0584443 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Mon, 5 Aug 2024 02:42:08 +0000 Subject: [PATCH 0046/1485] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E6=A3=80=E8=A7=86?= =?UTF-8?q?=E6=84=8F=E8=A7=81=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/src/liteos_adapter.c | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/ddk/host/src/liteos_adapter.c b/usb/ddk/host/src/liteos_adapter.c index be6f2923e9..4fb713d3d6 100644 --- a/usb/ddk/host/src/liteos_adapter.c +++ b/usb/ddk/host/src/liteos_adapter.c @@ -647,7 +647,6 @@ static int32_t OsSubmitBulkRequestHandle( request->reqStatus = USB_REQUEST_ERROR; } OsDiscardUrbs(request, 0, i); - RawUsbMemFree(pas); OsalMutexUnlock(&request->lock); return HDF_SUCCESS; } -- Gitee From b61e35af0bf614ae61b376ec2f155fee32d2f947 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 5 Aug 2024 06:21:13 +0000 Subject: [PATCH 0047/1485] update display/buffer/hdi_service/dfx/display_buffer_dfx.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- display/buffer/hdi_service/dfx/display_buffer_dfx.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp index 2bb7787586..1a5a6dfacb 100644 --- a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp +++ b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp @@ -28,7 +28,9 @@ namespace V1_0 { DisplayBufferDfx::DisplayBufferDfx(std::string name) : dfxName_(name), timeId_(0), - flag_(false) + flag_(false), + startTimeStamp({0, 0}), + stopTimeStamp({0, 0}) { } -- Gitee From 79dd2612536006e30763b23b376ddded0c9f256e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Mon, 5 Aug 2024 06:25:06 +0000 Subject: [PATCH 0048/1485] fix controlParams.size MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/hdi_service/src/usb_impl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index d56cf83c15..b3147c78bb 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1646,7 +1646,7 @@ int32_t UsbImpl::ControlTransferReadwithLength( controlParams.directon = (UsbRequestDirection)(((static_cast(ctrlParams.requestType)) >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK); controlParams.reqType = static_cast(ctrlParams.requestType); - controlParams.size = ctrlParams.length; + controlParams.size = ctrlParams.length == 0 ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length; controlParams.data = static_cast(OsalMemCalloc(controlParams.size)); if (controlParams.data == nullptr) { HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__); -- Gitee From deefa620da078a8ae6a60e7724426e09100db9ef Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Mon, 5 Aug 2024 06:24:29 +0000 Subject: [PATCH 0049/1485] release interface set to nullptr Signed-off-by: yuzhiqiang --- usb/hdi_service/src/usb_impl.cpp | 44 +++++++++++++++++--------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 9d186d5c52..2db8b09a66 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1379,31 +1379,35 @@ int32_t UsbImpl::ReleaseInterface(const UsbDev &dev, uint8_t interfaceId) return HDF_DEV_ERR_NO_DEVICE; } - UsbInterfaceHandle *interfaceHandle = InterfaceIdToHandle(port, interfaceId); - if (interfaceHandle == nullptr || interfaceId >= USB_MAX_INTERFACES) { + if (interfaceId == MAX_INTERFACEID) { + if (port->ctrIface != nullptr) { + UsbReleaseInterface(port->ctrIface); + port->ctrIface = nullptr; + } + + if (port->ctrDevHandle != nullptr) { + UsbCloseInterface(port->ctrDevHandle, false); + port->ctrDevHandle = nullptr; + } + return HDF_SUCCESS; + } else if (interfaceId < USB_MAX_INTERFACES) { + if (port->iface[interfaceId] != nullptr) { + UsbReleaseInterface(port->iface[interfaceId]); + port->iface[interfaceId] = nullptr; + } + + if (port->devHandle[interfaceId] != nullptr) { + UsbCloseInterface(port->devHandle[interfaceId], false); + port->devHandle[interfaceId] = nullptr; + } + return HDF_SUCCESS; + } else { HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__, port->busNum, port->devAddr, interfaceId); return HDF_FAILURE; } - - struct UsbInterface *interface = nullptr; - int32_t ret = GetInterfaceByHandle(interfaceHandle, &interface); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s get interface failed %{public}d", __func__, ret); - return ret; - } - ret = UsbCloseInterface(interfaceHandle, false); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s close interface failed %{public}d", __func__, ret); - return ret; - } - - ret = UsbReleaseInterface(interface); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s:ReleaseInterface failed, ret = %{public}d", __func__, ret); - } - return ret; + return HDF_SUCCESS; } int32_t UsbImpl::SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex) -- Gitee From 502be564064024f209d55d25c141f89e5696ed6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 5 Aug 2024 07:20:48 +0000 Subject: [PATCH 0050/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- .../primary_impl/vdi_src/audio_render_vdi.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 6ad890775e..40b817b1ed 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -901,11 +901,21 @@ struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct Audio for (index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) { if ((renderPriv->renderInfos[index] != NULL) && + (attrs->type == AUDIO_IN_MEDIA || attrs->type == AUDIO_MULTI_CHANNEL) && (renderPriv->renderInfos[index]->streamType == attrs->type)) { *rendrId = renderPriv->renderInfos[index]->renderId; renderPriv->renderInfos[index]->usrCount++; return &renderPriv->renderInfos[index]->render; } + if ((renderPriv->renderInfos[index] != NULL) && + (renderPriv->renderInfos[index]->desc.pins == pin) && + (renderPriv->renderInfos[index]->streamType == attrs->type) && + (renderPriv->renderInfos[index]->sampleRate == attrs->sampleRate) && + (renderPriv->renderInfos[index]->channelCount == attrs->channelCount)) { + *rendrId = renderPriv->renderInfos[index]->renderId; + renderPriv->renderInfos[index]->usrCount++; + return &renderPriv->renderInfos[index]->render; + } } return NULL; -- Gitee From 5646f3e71f1ef126945019172f2db77ad87b9c6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 5 Aug 2024 07:29:25 +0000 Subject: [PATCH 0051/1485] update camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp index 6497ae82f0..b2f01ab087 100644 --- a/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/camera_tag_uttest_v1_1.cpp @@ -222,7 +222,7 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_005, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is 0 ...\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES value count is 0 ..."); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.u8 == nullptr) { printf("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_AUTO_VALUES data is NULL!"); return; @@ -265,7 +265,7 @@ HWTEST_F(CameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_009, TestSize.Level1) printf("OHOS_ABILITY_CUSTOM_VIDEO_FPS value count is 0 ...\n"); CAMERA_LOGI("OHOS_ABILITY_CUSTOM_VIDEO_FPS value count is 0 ..."); return; - } else if (entry.data.u8 != nullptr) { + } else if (entry.data.i32 == nullptr) { printf("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_CUSTOM_VIDEO_FPS data is NULL!"); return; -- Gitee From 690c372544e14911c2ddfc83651c2bc75f017745 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Mon, 5 Aug 2024 17:23:48 +0800 Subject: [PATCH 0052/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- codec/test/benchmarktest/BUILD.gn | 2 +- codec/test/demo/adapter/BUILD.gn | 2 +- codec/test/demo/idl/BUILD.gn | 4 ++-- codec/test/demo/jpeg/BUILD.gn | 2 +- codec/test/demo/v1.0/BUILD.gn | 8 ++++---- codec/test/demo/v2.0/BUILD.gn | 4 ++-- codec/test/unittest/hdi_image/BUILD.gn | 2 +- codec/test/unittest/hdi_omx/BUILD.gn | 2 +- codec/test/unittest/idl_omx/BUILD.gn | 2 +- display/buffer/test/benchmarktest/BUILD.gn | 2 +- display/buffer/test/fuzztest/metadata_fuzzer/BUILD.gn | 2 +- display/buffer/test/moduletest/BUILD.gn | 2 +- display/buffer/test/unittest/BUILD.gn | 4 ++-- display/composer/hdi_service/BUILD.gn | 2 +- display/composer/test/benchmark/BUILD.gn | 2 +- display/composer/test/common/BUILD.gn | 2 +- display/composer/test/fuzztest/device_fuzzer/BUILD.gn | 2 +- display/composer/test/fuzztest/layer_fuzzer/BUILD.gn | 4 ++-- display/composer/test/moduletest/BUILD.gn | 2 +- display/composer/test/unittest/BUILD.gn | 4 ++-- 20 files changed, 28 insertions(+), 28 deletions(-) diff --git a/codec/test/benchmarktest/BUILD.gn b/codec/test/benchmarktest/BUILD.gn index c1a2879803..ef3a58a837 100644 --- a/codec/test/benchmarktest/BUILD.gn +++ b/codec/test/benchmarktest/BUILD.gn @@ -38,7 +38,7 @@ ohos_benchmarktest("hdf_codec_benchmark_test") { "drivers_interface_codec:libcodec_proxy_3.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", diff --git a/codec/test/demo/adapter/BUILD.gn b/codec/test/demo/adapter/BUILD.gn index bfc1665e5c..030b9df337 100644 --- a/codec/test/demo/adapter/BUILD.gn +++ b/codec/test/demo/adapter/BUILD.gn @@ -58,7 +58,7 @@ ohos_executable("codec_hdi_adapter_encode") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_hdi_passthrough_impl", "drivers_peripheral_display:hdi_gralloc_client", diff --git a/codec/test/demo/idl/BUILD.gn b/codec/test/demo/idl/BUILD.gn index 6b3218ce7c..04536ff331 100644 --- a/codec/test/demo/idl/BUILD.gn +++ b/codec/test/demo/idl/BUILD.gn @@ -31,7 +31,7 @@ ohos_executable("codec_idl_omx_decode") { "drivers_interface_codec:libcodec_proxy_3.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", @@ -69,7 +69,7 @@ ohos_executable("codec_idl_omx_encode") { "drivers_interface_codec:libcodec_proxy_3.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", diff --git a/codec/test/demo/jpeg/BUILD.gn b/codec/test/demo/jpeg/BUILD.gn index 0f5f25f09a..e02122770e 100644 --- a/codec/test/demo/jpeg/BUILD.gn +++ b/codec/test/demo/jpeg/BUILD.gn @@ -28,7 +28,7 @@ ohos_executable("codec_jpeg_decode") { "drivers_interface_codec:libimage_proxy_1.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", diff --git a/codec/test/demo/v1.0/BUILD.gn b/codec/test/demo/v1.0/BUILD.gn index 6b8020784b..f524ecd0ce 100644 --- a/codec/test/demo/v1.0/BUILD.gn +++ b/codec/test/demo/v1.0/BUILD.gn @@ -39,7 +39,7 @@ ohos_executable("codec_decode_test_ipc") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_client", "drivers_peripheral_display:hdi_gralloc_client", @@ -85,7 +85,7 @@ ohos_executable("codec_encode_test_ipc") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_client", "drivers_peripheral_display:hdi_gralloc_client", @@ -131,7 +131,7 @@ ohos_executable("codec_decode_test_async") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_client", "drivers_peripheral_display:hdi_gralloc_client", @@ -177,7 +177,7 @@ ohos_executable("codec_encode_test_async") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_client", "drivers_peripheral_display:hdi_gralloc_client", diff --git a/codec/test/demo/v2.0/BUILD.gn b/codec/test/demo/v2.0/BUILD.gn index 8f1c72a757..bdc800b88e 100644 --- a/codec/test/demo/v2.0/BUILD.gn +++ b/codec/test/demo/v2.0/BUILD.gn @@ -27,7 +27,7 @@ ohos_executable("codec_hdi_omx_decode") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_hdi_omx_client", "graphic_surface:buffer_handle", @@ -63,7 +63,7 @@ ohos_executable("codec_hdi_omx_encode") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_hdi_omx_client", "graphic_surface:buffer_handle", diff --git a/codec/test/unittest/hdi_image/BUILD.gn b/codec/test/unittest/hdi_image/BUILD.gn index 762ad50e09..03dc65fb4e 100644 --- a/codec/test/unittest/hdi_image/BUILD.gn +++ b/codec/test/unittest/hdi_image/BUILD.gn @@ -25,7 +25,7 @@ ohos_unittest("codec_hdi_jpeg_test") { "drivers_interface_codec:libimage_proxy_1.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", diff --git a/codec/test/unittest/hdi_omx/BUILD.gn b/codec/test/unittest/hdi_omx/BUILD.gn index bd1c949444..0a9c54f1ba 100644 --- a/codec/test/unittest/hdi_omx/BUILD.gn +++ b/codec/test/unittest/hdi_omx/BUILD.gn @@ -28,7 +28,7 @@ ohos_unittest("codec_hdi_omx_test") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "drivers_peripheral_codec:libcodec_hdi_omx_client", "graphic_surface:buffer_handle", diff --git a/codec/test/unittest/idl_omx/BUILD.gn b/codec/test/unittest/idl_omx/BUILD.gn index c116dda0ca..0ef42d6c70 100644 --- a/codec/test/unittest/idl_omx/BUILD.gn +++ b/codec/test/unittest/idl_omx/BUILD.gn @@ -35,7 +35,7 @@ ohos_unittest("codec_idl_omx_test") { "drivers_interface_codec:libcodec_proxy_3.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", diff --git a/display/buffer/test/benchmarktest/BUILD.gn b/display/buffer/test/benchmarktest/BUILD.gn index 548ac9cd86..eb457441ef 100644 --- a/display/buffer/test/benchmarktest/BUILD.gn +++ b/display/buffer/test/benchmarktest/BUILD.gn @@ -37,7 +37,7 @@ ohos_benchmarktest("hdf_display_buffer_benchmarktest") { "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_1", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_buffer_proxy_1.1", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "googletest:gtest", "hdf_core:libhdf_utils", diff --git a/display/buffer/test/fuzztest/metadata_fuzzer/BUILD.gn b/display/buffer/test/fuzztest/metadata_fuzzer/BUILD.gn index 7398ad80ba..989dbe3b50 100644 --- a/display/buffer/test/fuzztest/metadata_fuzzer/BUILD.gn +++ b/display/buffer/test/fuzztest/metadata_fuzzer/BUILD.gn @@ -24,7 +24,7 @@ ohos_fuzztest("MetadataFuzzTest") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_1", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", diff --git a/display/buffer/test/moduletest/BUILD.gn b/display/buffer/test/moduletest/BUILD.gn index 61e3aa71e7..b46e9c440a 100644 --- a/display/buffer/test/moduletest/BUILD.gn +++ b/display/buffer/test/moduletest/BUILD.gn @@ -27,7 +27,7 @@ ohos_moduletest("hdf_disp_buffer_moduletest") { "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_1", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_buffer_proxy_1.1", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "googletest:gtest", "graphic_surface:buffer_handle", diff --git a/display/buffer/test/unittest/BUILD.gn b/display/buffer/test/unittest/BUILD.gn index aca832d02d..226a881d4f 100644 --- a/display/buffer/test/unittest/BUILD.gn +++ b/display/buffer/test/unittest/BUILD.gn @@ -27,7 +27,7 @@ ohos_unittest("hdf_disp_buffer_unittest") { "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_1", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_buffer_proxy_1.1", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "googletest:gtest", "graphic_surface:buffer_handle", @@ -50,7 +50,7 @@ ohos_unittest("buffer_death_test") { "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_1", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_buffer_proxy_1.1", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", "googletest:gtest", "graphic_surface:buffer_handle", diff --git a/display/composer/hdi_service/BUILD.gn b/display/composer/hdi_service/BUILD.gn index 3cefe404a9..29983eb3f3 100644 --- a/display/composer/hdi_service/BUILD.gn +++ b/display/composer/hdi_service/BUILD.gn @@ -36,7 +36,7 @@ ohos_shared_library("libdisplay_composer_service_1.2") { "drivers_interface_display:libdisplay_buffer_stub_1.0", "drivers_interface_display:libdisplay_buffer_stub_1.1", "drivers_interface_display:libdisplay_buffer_stub_1.2", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.0", "drivers_interface_display:libdisplay_composer_stub_1.1", "drivers_interface_display:libdisplay_composer_stub_1.2", diff --git a/display/composer/test/benchmark/BUILD.gn b/display/composer/test/benchmark/BUILD.gn index 7ccb931b4c..332e63a0e9 100644 --- a/display/composer/test/benchmark/BUILD.gn +++ b/display/composer/test/benchmark/BUILD.gn @@ -37,7 +37,7 @@ ohos_benchmarktest("hdf_display_benchmark_test") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.1", "googletest:gtest", "hdf_core:libhdf_utils", diff --git a/display/composer/test/common/BUILD.gn b/display/composer/test/common/BUILD.gn index 044d4a4d47..3a4ee73598 100644 --- a/display/composer/test/common/BUILD.gn +++ b/display/composer/test/common/BUILD.gn @@ -39,7 +39,7 @@ ohos_static_library("disp_dev_hdi_test_common") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.1", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", diff --git a/display/composer/test/fuzztest/device_fuzzer/BUILD.gn b/display/composer/test/fuzztest/device_fuzzer/BUILD.gn index f7fb174ae7..daff289ec0 100644 --- a/display/composer/test/fuzztest/device_fuzzer/BUILD.gn +++ b/display/composer/test/fuzztest/device_fuzzer/BUILD.gn @@ -24,7 +24,7 @@ ohos_fuzztest("DeviceFuzzTest") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.1", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", diff --git a/display/composer/test/fuzztest/layer_fuzzer/BUILD.gn b/display/composer/test/fuzztest/layer_fuzzer/BUILD.gn index 3ca664c3ab..4d888d5974 100644 --- a/display/composer/test/fuzztest/layer_fuzzer/BUILD.gn +++ b/display/composer/test/fuzztest/layer_fuzzer/BUILD.gn @@ -24,8 +24,8 @@ ohos_fuzztest("LayerFuzzTest") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.1", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", diff --git a/display/composer/test/moduletest/BUILD.gn b/display/composer/test/moduletest/BUILD.gn index 6570da5a03..50753fcc56 100644 --- a/display/composer/test/moduletest/BUILD.gn +++ b/display/composer/test/moduletest/BUILD.gn @@ -36,7 +36,7 @@ ohos_moduletest("composer_mt") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.0", "googletest:gtest", "graphic_surface:buffer_handle", diff --git a/display/composer/test/unittest/BUILD.gn b/display/composer/test/unittest/BUILD.gn index 369d1ec54b..f14287d199 100644 --- a/display/composer/test/unittest/BUILD.gn +++ b/display/composer/test/unittest/BUILD.gn @@ -39,7 +39,7 @@ ohos_unittest("composer_ut") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.1", "googletest:gtest", "graphic_surface:buffer_handle", @@ -61,7 +61,7 @@ ohos_unittest("composer_death_test") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_stub_1.0", "googletest:gtest", "graphic_surface:buffer_handle", -- Gitee From a370467f72975559cb20b49c4ed08e764bf60867 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Mon, 5 Aug 2024 17:39:26 +0800 Subject: [PATCH 0053/1485] add fuzz Signed-off-by: suxiaosu007 --- .../hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp index cf60840910..06d4b96b9d 100644 --- a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp +++ b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp @@ -79,7 +79,7 @@ namespace Codec { if (err != HDF_SUCCESS || count <= 0) { HDF_LOGE("%{public}s GetComponentNum return %{public}d, count = %{public}d", __func__, err, count); Release(); - return HDF_FAILURE; + return false; } std::vector caps; @@ -87,7 +87,7 @@ namespace Codec { if (err != HDF_SUCCESS) { HDF_LOGE("%{public}s GetComponentCapabilityList return %{public}d", __func__, err); Release(); - return err; + return false; } int32_t ret = g_manager->CreateComponent(g_component, g_componentId, caps[0].compName, g_appData, g_callback); -- Gitee From dd0de2e61665ca4617087a39b703b37db4755276 Mon Sep 17 00:00:00 2001 From: chenweijian Date: Mon, 5 Aug 2024 17:46:10 +0800 Subject: [PATCH 0054/1485] =?UTF-8?q?=E8=B4=A6=E5=8F=B7PIN=E7=A0=81?= =?UTF-8?q?=E5=BD=95=E5=85=A5=E3=80=81=E4=BF=AE=E6=94=B9=E5=A4=B1=E8=B4=A5?= =?UTF-8?q?=EF=BC=8C=E6=94=AF=E6=8C=81=E8=B4=A6=E5=8F=B7=E8=B0=83=E7=94=A8?= =?UTF-8?q?=E5=88=A0=E9=99=A4=E7=BC=93=E5=AD=98=E7=9A=84=E5=87=AD=E6=8D=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: chenweijian Change-Id: Ie1d0006f24cc51b942b646f472a4f175e62a163b --- user_auth/hdi_service/database/src/idm_database.c | 3 +++ user_auth/hdi_service/idm/src/enroll_specification_check.c | 3 ++- user_auth/hdi_service/service/user_auth_interface_service.cpp | 2 +- user_auth/test/unittest/database/idm_database_test.cpp | 2 +- 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/user_auth/hdi_service/database/src/idm_database.c b/user_auth/hdi_service/database/src/idm_database.c index 8f80cea6b5..7e752446ed 100644 --- a/user_auth/hdi_service/database/src/idm_database.c +++ b/user_auth/hdi_service/database/src/idm_database.c @@ -719,6 +719,9 @@ ResultCode DeleteCredentialInfo(int32_t userId, uint64_t credentialId, Credentia LOG_ERROR("remove credential failed"); return ret; } + if (credentialInfo->authType == DEFAULT_AUTH_TYPE) { + return UpdateFileInfo(g_userInfoList); + } credentialQuery = QueryCredentialByAuthType(credentialInfo->authType, credentialList); if (credentialQuery != NULL) { return UpdateFileInfo(g_userInfoList); diff --git a/user_auth/hdi_service/idm/src/enroll_specification_check.c b/user_auth/hdi_service/idm/src/enroll_specification_check.c index 2326555bbf..47772a326c 100644 --- a/user_auth/hdi_service/idm/src/enroll_specification_check.c +++ b/user_auth/hdi_service/idm/src/enroll_specification_check.c @@ -62,7 +62,8 @@ ResultCode CheckIdmOperationToken(int32_t userId, UserAuthTokenHal *authToken) LOG_ERROR("need pin token"); return RESULT_VERIFY_TOKEN_FAIL; } - if ((tokenPlain.tokenDataPlain.authMode != SCHEDULE_MODE_AUTH) + if ((tokenPlain.tokenDataPlain.authMode != SCHEDULE_MODE_AUTH && + tokenPlain.tokenDataPlain.authMode != SCHEDULE_MODE_ENROLL) || (tokenPlain.tokenDataPlain.tokenType != TOKEN_TYPE_LOCAL_AUTH)) { LOG_ERROR("need local auth"); return RESULT_VERIFY_TOKEN_FAIL; diff --git a/user_auth/hdi_service/service/user_auth_interface_service.cpp b/user_auth/hdi_service/service/user_auth_interface_service.cpp index cea607d5fc..bfb8dc6a3b 100644 --- a/user_auth/hdi_service/service/user_auth_interface_service.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_service.cpp @@ -1146,7 +1146,7 @@ int32_t UserAuthInterfaceService::DeleteUser(int32_t userId, const std::vectorbuf, oldRootSecret->contentSize) != EOK) { IAM_LOGE("rootSecret copy failed"); diff --git a/user_auth/test/unittest/database/idm_database_test.cpp b/user_auth/test/unittest/database/idm_database_test.cpp index ab42359e7f..0e4269a25d 100644 --- a/user_auth/test/unittest/database/idm_database_test.cpp +++ b/user_auth/test/unittest/database/idm_database_test.cpp @@ -409,7 +409,7 @@ HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_003, TestSize.Level0) userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast(credInfo)); g_userInfoList->insert(g_userInfoList, static_cast(&userInfo)); CredentialInfoHal info = {}; - EXPECT_EQ(DeleteCredentialInfo(userId, credentialId, &info), 10006); + EXPECT_EQ(DeleteCredentialInfo(userId, credentialId, &info), RESULT_SUCCESS); } HWTEST_F(IdmDatabaseTest, TestDeleteCredentialInfo_004, TestSize.Level0) -- Gitee From b2327e777c8dfe6f7d77bf8ae0397944bc0c5217 Mon Sep 17 00:00:00 2001 From: pingliao Date: Fri, 26 Jul 2024 16:41:36 +0800 Subject: [PATCH 0055/1485] fix: codeCheck Signed-off-by: pingliao --- usb/ddk_service/src/usb_ddk_service.cpp | 2 ++ usb/gadget/function/mtp/src/usbfn_mtp_impl.cpp | 4 ++++ usb/hdi_service/src/usb_interface_driver.cpp | 4 ++++ usb/hdi_service/src/usbd_dispatcher.cpp | 1 + usb/net/src/cdc_ether.c | 2 ++ usb/serial/src/usb_serial.c | 2 ++ 6 files changed, 15 insertions(+) diff --git a/usb/ddk_service/src/usb_ddk_service.cpp b/usb/ddk_service/src/usb_ddk_service.cpp index 7468b96669..3f0b59bc39 100644 --- a/usb/ddk_service/src/usb_ddk_service.cpp +++ b/usb/ddk_service/src/usb_ddk_service.cpp @@ -117,6 +117,8 @@ int32_t UsbDdkService::Init() g_pnpListener->callBack = UsbdPnpEventHandler; if (DdkListenerMgrAdd(g_pnpListener) != HDF_SUCCESS) { HDF_LOGE("%{public}s: add listener failed", __func__); + delete g_pnpListener; + g_pnpListener = nullptr; return HDF_FAILURE; } } diff --git a/usb/gadget/function/mtp/src/usbfn_mtp_impl.cpp b/usb/gadget/function/mtp/src/usbfn_mtp_impl.cpp index 962680822e..097a1667cf 100755 --- a/usb/gadget/function/mtp/src/usbfn_mtp_impl.cpp +++ b/usb/gadget/function/mtp/src/usbfn_mtp_impl.cpp @@ -922,6 +922,8 @@ int32_t UsbfnMtpImpl::Init() int32_t ret = UsbfnMtpImpl::UsbMtpDeviceCreateFuncDevice(); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: UsbMtpDeviceCreateFuncDevice failed", __func__); + (void)OsalMemFree(mtpDev_); + mtpDev_ = nullptr; return ret; } /* init mtpPort */ @@ -1331,6 +1333,8 @@ int32_t UsbfnMtpImpl::ReceiveFileEx() int32_t ret = UsbMtpPortStartRxAsync(mtpPort_); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: start async tx failed: %{public}d", __func__, ret); + (void)OsalMemFree(mtpDev_->asyncRecvWriteTempContent); + mtpDev_->asyncRecvWriteTempContent = nullptr; return HDF_ERR_IO; } HDF_LOGV("%{public}s: wait async rx", __func__); diff --git a/usb/hdi_service/src/usb_interface_driver.cpp b/usb/hdi_service/src/usb_interface_driver.cpp index ff67398bc5..6431b42297 100644 --- a/usb/hdi_service/src/usb_interface_driver.cpp +++ b/usb/hdi_service/src/usb_interface_driver.cpp @@ -83,6 +83,7 @@ static int HdfUsbInterfaceDriverBind(struct HdfDeviceObject * const deviceObject if (serviceImpl == nullptr) { HDF_LOGE("%{public}s: failed to get of implement service", __func__); delete hdfUsbInterfaceHost; + hdfUsbInterfaceHost = nullptr; return HDF_FAILURE; } @@ -92,6 +93,7 @@ static int HdfUsbInterfaceDriverBind(struct HdfDeviceObject * const deviceObject if (hdfUsbInterfaceHost->stub == nullptr) { HDF_LOGE("%{public}s: failed to get stub object", __func__); delete hdfUsbInterfaceHost; + hdfUsbInterfaceHost = nullptr; return HDF_FAILURE; } deviceObject->service = &hdfUsbInterfaceHost->ioService; @@ -101,6 +103,8 @@ static int HdfUsbInterfaceDriverBind(struct HdfDeviceObject * const deviceObject int32_t ret = UsbImpl::UsbdEventHandle(impl); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: UsbdEventHandle failed", __func__); + delete hdfUsbInterfaceHost; + hdfUsbInterfaceHost = nullptr; return HDF_FAILURE; } return HDF_SUCCESS; diff --git a/usb/hdi_service/src/usbd_dispatcher.cpp b/usb/hdi_service/src/usbd_dispatcher.cpp index 3c61ad653a..fb0bdbcf20 100644 --- a/usb/hdi_service/src/usbd_dispatcher.cpp +++ b/usb/hdi_service/src/usbd_dispatcher.cpp @@ -1213,6 +1213,7 @@ int32_t UsbdDispatcher::UsbdBulkASyncPutAsmData(UsbdBufferHandle *handle, uint8_ ret = memcpy_s(handle->starAddr + handle->rcur, tlen, buffer, len); if (ret != EOK) { HDF_LOGE("%{public}s:%{public}d memcpy_s failed", __func__, ret); + OsalMutexUnlock(&handle->lock); return ret; } diff --git a/usb/net/src/cdc_ether.c b/usb/net/src/cdc_ether.c index 06d14b6654..3c47331909 100644 --- a/usb/net/src/cdc_ether.c +++ b/usb/net/src/cdc_ether.c @@ -795,6 +795,8 @@ static void EcmCtrlIrq(struct UsbRequest *req) &ecm->notificationBuffer[ecm->nbIndex], ecm->nbSize - ecm->nbIndex, req->compInfo.buffer, copySize); if (ret != EOK) { HDF_LOGE("%{public}s: memcpy_s failed", __func__); + OsalMemFree(ecm->notificationBuffer); + ecm->notificationBuffer = NULL; return; } ecm->nbIndex += copySize; diff --git a/usb/serial/src/usb_serial.c b/usb/serial/src/usb_serial.c index 16173ad739..de6dc8d0f3 100644 --- a/usb/serial/src/usb_serial.c +++ b/usb/serial/src/usb_serial.c @@ -1295,6 +1295,8 @@ static int32_t AcmCtrlIrqCheckSize(struct UsbRequest * const req, struct AcmDevi if (memcpy_s(&acm->notificationBuffer[acm->nbIndex], acm->nbSize - acm->nbIndex, req->compInfo.buffer, copySize) != EOK) { HDF_LOGE("%{public}s:%{public}d memcpy_s failed", __func__, __LINE__); + OsalMemFree(acm->notificationBuffer); + acm->notificationBuffer = NULL; } acm->nbIndex += copySize; currentSize = acm->nbIndex; -- Gitee From b3865fc59e74ab10672b145e5031ad814d909ef2 Mon Sep 17 00:00:00 2001 From: lee Date: Mon, 5 Aug 2024 17:28:28 +0800 Subject: [PATCH 0056/1485] Fix blue_host DeathRecipient, add init action timer log Signed-off-by: lee --- bluetooth/hci/hdi_service/hci_interface_impl.cpp | 9 ++++++--- bluetooth/hci/hdi_service/implement/vendor_interface.cpp | 8 ++++++++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/bluetooth/hci/hdi_service/hci_interface_impl.cpp b/bluetooth/hci/hdi_service/hci_interface_impl.cpp index f91203241c..dd314411e2 100644 --- a/bluetooth/hci/hdi_service/hci_interface_impl.cpp +++ b/bluetooth/hci/hdi_service/hci_interface_impl.cpp @@ -59,6 +59,9 @@ int32_t HciInterfaceImpl::Init(const sptr& callbackObj) return HDF_FAILURE; } + AddHciDeathRecipient(callbackObj); + callbacks_ = callbackObj; + VendorInterface::ReceiveCallback callback = { .onAclReceive = [callbackObj]( @@ -74,9 +77,9 @@ int32_t HciInterfaceImpl::Init(const sptr& callbackObj) bool result = VendorInterface::GetInstance()->Initialize( [callbackObj](bool status) { callbackObj->OnInited(status ? BtStatus::SUCCESS : BtStatus::INITIAL_ERROR); }, callback); - if (result) { - callbacks_ = callbackObj; - AddHciDeathRecipient(callbacks_); + if (!result) { + RemoveHciDeathRecipient(callbackObj); + callbacks_ = nullptr; } return result ? HDF_SUCCESS : HDF_FAILURE; } diff --git a/bluetooth/hci/hdi_service/implement/vendor_interface.cpp b/bluetooth/hci/hdi_service/implement/vendor_interface.cpp index 9d06e15551..d04d881db0 100644 --- a/bluetooth/hci/hdi_service/implement/vendor_interface.cpp +++ b/bluetooth/hci/hdi_service/implement/vendor_interface.cpp @@ -56,12 +56,14 @@ VendorInterface::~VendorInterface() bool VendorInterface::WatchHciChannel(const ReceiveCallback &receiveCallback) { + HDF_LOGI("VendorInterface BT_OP_HCI_CHANNEL_OPEN begin"); int channel[HCI_MAX_CHANNEL] = {0}; int channelCount = vendorInterface_->op(BtOpcodeT::BT_OP_HCI_CHANNEL_OPEN, channel); if (channelCount < 1 || channelCount > HCI_MAX_CHANNEL) { HDF_LOGE("vendorInterface_->op BT_OP_HCI_CHANNEL_OPEN failed ret:%d.", channelCount); return false; } + HDF_LOGI("VendorInterface BT_OP_HCI_CHANNEL_OPEN end"); if (channelCount == 1) { auto h4 = std::make_shared(channel[0], @@ -93,6 +95,7 @@ bool VendorInterface::Initialize( initializeCompleteCallback_ = initializeCompleteCallback; eventDataCallback_ = receiveCallback.onEventReceive; + HDF_LOGI("VendorInterface dlopen"); vendorHandle_ = dlopen(BT_VENDOR_NAME, RTLD_NOW); if (vendorHandle_ == nullptr) { HDF_LOGE("VendorInterface dlopen %{public}s failed, error code: %{public}s", BT_VENDOR_NAME, dlerror()); @@ -112,6 +115,8 @@ bool VendorInterface::Initialize( HDF_LOGE("VendorInterface dlsym %{public}s failed.", BT_VENDOR_INTERFACE_SYMBOL_NAME); return false; } + + HDF_LOGI("VendorInterface init"); int result = vendorInterface_->init(&vendorCallbacks_, address.data()); if (result != 0) { HDF_LOGE("vendorInterface_->init failed."); @@ -137,8 +142,11 @@ bool VendorInterface::Initialize( HDF_LOGE("vendorInterface_ is nullptr"); return false; } + + HDF_LOGI("VendorInterface BT_OP_INIT"); vendorInterface_->op(BtOpcodeT::BT_OP_INIT, nullptr); + HDF_LOGI("VendorInterface Initialize end"); return true; } -- Gitee From 4645ccbb6cc188a9ceecc9201c40ed069a079fc4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Mon, 5 Aug 2024 20:30:59 +0800 Subject: [PATCH 0057/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- display/composer/hdi_service/include/idisplay_composer_vdi.h | 2 +- display/composer/test/benchmark/display_benchmark_test.cpp | 2 +- display/composer/test/common/hdi_test_device.h | 2 +- display/composer/test/common/hdi_test_display.h | 2 +- display/composer/test/fuzztest/common/display_common_fuzzer.h | 2 +- display/composer/test/moduletest/hdi_device_test.cpp | 2 +- display/composer/test/unittest/hdi_composer_ut.cpp | 4 ++-- display/composer/test/unittest/hdi_death_test.h | 2 +- 8 files changed, 9 insertions(+), 9 deletions(-) diff --git a/display/composer/hdi_service/include/idisplay_composer_vdi.h b/display/composer/hdi_service/include/idisplay_composer_vdi.h index f054812062..15240c2430 100644 --- a/display/composer/hdi_service/include/idisplay_composer_vdi.h +++ b/display/composer/hdi_service/include/idisplay_composer_vdi.h @@ -19,7 +19,7 @@ #include #include #include "buffer_handle.h" -#include "v1_0/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_0/display_composer_type.h" namespace OHOS { diff --git a/display/composer/test/benchmark/display_benchmark_test.cpp b/display/composer/test/benchmark/display_benchmark_test.cpp index a35b58800b..7631b820fc 100644 --- a/display/composer/test/benchmark/display_benchmark_test.cpp +++ b/display/composer/test/benchmark/display_benchmark_test.cpp @@ -20,7 +20,7 @@ #include #include #include "gtest/gtest.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" diff --git a/display/composer/test/common/hdi_test_device.h b/display/composer/test/common/hdi_test_device.h index 91e878adbf..ecd95f8268 100644 --- a/display/composer/test/common/hdi_test_device.h +++ b/display/composer/test/common/hdi_test_device.h @@ -18,7 +18,7 @@ #include #include #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "hdi_test_device_common.h" #include "hdi_test_display.h" diff --git a/display/composer/test/common/hdi_test_display.h b/display/composer/test/common/hdi_test_display.h index 9d0fe92368..0bb89aa508 100644 --- a/display/composer/test/common/hdi_test_display.h +++ b/display/composer/test/common/hdi_test_display.h @@ -17,7 +17,7 @@ #define HDI_TEST_DISPLAY_H #include #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "display_test.h" #include "hdi_test_device_common.h" diff --git a/display/composer/test/fuzztest/common/display_common_fuzzer.h b/display/composer/test/fuzztest/common/display_common_fuzzer.h index 8c73f8a143..3877c572eb 100644 --- a/display/composer/test/fuzztest/common/display_common_fuzzer.h +++ b/display/composer/test/fuzztest/common/display_common_fuzzer.h @@ -17,7 +17,7 @@ #define DISPLAY_COMMON_FUZZER_H #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "buffer_handle.h" diff --git a/display/composer/test/moduletest/hdi_device_test.cpp b/display/composer/test/moduletest/hdi_device_test.cpp index 6e635deca9..407bab32e7 100644 --- a/display/composer/test/moduletest/hdi_device_test.cpp +++ b/display/composer/test/moduletest/hdi_device_test.cpp @@ -17,7 +17,7 @@ #include #include #include -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" diff --git a/display/composer/test/unittest/hdi_composer_ut.cpp b/display/composer/test/unittest/hdi_composer_ut.cpp index a1bfbbc995..18e7009ee9 100644 --- a/display/composer/test/unittest/hdi_composer_ut.cpp +++ b/display/composer/test/unittest/hdi_composer_ut.cpp @@ -17,8 +17,8 @@ #include #include #include -#include "v1_0/include/idisplay_composer_interface.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" diff --git a/display/composer/test/unittest/hdi_death_test.h b/display/composer/test/unittest/hdi_death_test.h index 9b55cb0d92..8ab54068df 100644 --- a/display/composer/test/unittest/hdi_death_test.h +++ b/display/composer/test/unittest/hdi_death_test.h @@ -23,7 +23,7 @@ #include "v1_0/display_composer_type.h" #include "v1_0/display_buffer_type.h" -#include "v1_0/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "display_test_utils.h" #include "gtest/gtest.h" -- Gitee From 66010e617138d2d7e3f5706f508be26f0cb472dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 5 Aug 2024 12:31:56 +0000 Subject: [PATCH 0058/1485] update camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp index 9f4f8ae17a..5a9ac810f2 100644 --- a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp @@ -171,7 +171,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_007, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES value count is 0"); return; - } else if (entry.data.u8 == nullptr) { + } else if (entry.data.i32 == nullptr) { printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); return; -- Gitee From 83bbdfd82d0dae3c20208f8a0bcc2adc32c331e3 Mon Sep 17 00:00:00 2001 From: chenjunwu Date: Mon, 5 Aug 2024 21:31:50 +0800 Subject: [PATCH 0059/1485] fix: join theard during destruction Signed-off-by: chenjunwu --- .../hdi_service/include/battery_thread.h | 6 ++++-- .../hdi_service/src/battery_thread.cpp | 18 +++++++++++++----- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/battery/interfaces/hdi_service/include/battery_thread.h b/battery/interfaces/hdi_service/include/battery_thread.h index 354daf3326..a832ed6276 100644 --- a/battery/interfaces/hdi_service/include/battery_thread.h +++ b/battery/interfaces/hdi_service/include/battery_thread.h @@ -36,12 +36,12 @@ enum EventType { class BatteryThread { public: - virtual ~BatteryThread() = default; + virtual ~BatteryThread(); void StartThread(void* service); void InitCallback(const sptr& callback); protected: - int32_t LoopingThreadEntry(void* arg); + void LoopingThreadEntry(void* arg); virtual void Run(void* service); virtual void UpdateBatteryInfo(void* service, const std::string& powerUevent); virtual void HandleStates() {} @@ -65,6 +65,8 @@ private: std::map callbacks_; std::unique_ptr provider_ = nullptr; UeventMap powerUeventMap_; + std::unique_ptr batteryThread_ {nullptr}; + std::atomic_bool isRunning_ {true}; }; } // namespace V2_0 } // namespace Battery diff --git a/battery/interfaces/hdi_service/src/battery_thread.cpp b/battery/interfaces/hdi_service/src/battery_thread.cpp index eb88066088..098dd9620b 100644 --- a/battery/interfaces/hdi_service/src/battery_thread.cpp +++ b/battery/interfaces/hdi_service/src/battery_thread.cpp @@ -38,6 +38,15 @@ const std::string POWER_SUPPLY = "SUBSYSTEM=power_supply"; } static sptr g_callback; +BatteryThread::~BatteryThread() +{ + BATTERY_HILOGW(COMP_HDI, "enter %{public}s", __func__); + isRunning_ = false; + if (batteryThread_ != nullptr && batteryThread_->joinable()) { + batteryThread_->join(); + } +} + void BatteryThread::InitCallback(const sptr& callback) { g_callback = callback; @@ -242,13 +251,13 @@ bool BatteryThread::CheckPowerUevent(const char* msg, std::string& powerUevent) return false; } -int32_t BatteryThread::LoopingThreadEntry(void* arg) +void BatteryThread::LoopingThreadEntry(void* arg) { int32_t nevents = 0; size_t size = callbacks_.size(); struct epoll_event events[size]; - while (true) { + while (isRunning_) { if (!nevents) { CycleMatters(); } @@ -283,9 +292,8 @@ void BatteryThread::StartThread(void* service) void BatteryThread::Run(void* service) { - std::thread batteryThread([this, service] { this->LoopingThreadEntry(service); }); - pthread_setname_np(batteryThread.native_handle(), "battery_thread"); - batteryThread.detach(); + batteryThread_ = std::make_unique([this, service] { this->LoopingThreadEntry(service); }); + pthread_setname_np(batteryThread_->native_handle(), "battery_thread"); } } // namespace V2_0 } // namespace Battery -- Gitee From a6a57823a23064f6f8be037c193248ae56f4538f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B1=85=E5=87=AF?= Date: Thu, 1 Aug 2024 18:58:28 +0800 Subject: [PATCH 0060/1485] fix: First unlock auth must be pinAuth MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 居凯 Change-Id: I6a07f8c995dec8ab2f4b53b61373b3d6e42350f2 --- .../hdi_service/database/inc/idm_common.h | 1 + .../hdi_service/database/inc/idm_database.h | 2 ++ .../hdi_service/database/src/idm_database.c | 26 +++++++++++++++++++ .../service/user_auth_interface_service.cpp | 20 ++++++++++++++ .../user_auth/src/user_auth_funcs.c | 12 +++++++++ 5 files changed, 61 insertions(+) diff --git a/user_auth/hdi_service/database/inc/idm_common.h b/user_auth/hdi_service/database/inc/idm_common.h index 1ba22adc20..e84e647d2f 100644 --- a/user_auth/hdi_service/database/inc/idm_common.h +++ b/user_auth/hdi_service/database/inc/idm_common.h @@ -52,6 +52,7 @@ typedef struct { LinkedList *credentialInfoList; LinkedList *enrolledInfoList; int32_t userType; + bool hasSuccessPinAuth; } UserInfo; typedef struct { diff --git a/user_auth/hdi_service/database/inc/idm_database.h b/user_auth/hdi_service/database/inc/idm_database.h index 337301b8ad..5e313e49c4 100644 --- a/user_auth/hdi_service/database/inc/idm_database.h +++ b/user_auth/hdi_service/database/inc/idm_database.h @@ -55,6 +55,8 @@ ResultCode GetSecureUid(int32_t userId, uint64_t *secUid); ResultCode GetEnrolledInfo(int32_t userId, EnrolledInfoHal **enrolledInfos, uint32_t *num); ResultCode GetEnrolledInfoAuthType(int32_t userId, uint32_t authType, EnrolledInfoHal *enrolledInfo); ResultCode DeleteUserInfo(int32_t userId, LinkedList **creds); +ResultCode SetHasSuccessPinAuth(int32_t userId, bool hasSuccessPinAuth); +ResultCode GetHasSuccessPinAuth(int32_t userId, bool *hasSuccessPinAuth); LinkedList *QueryCredentialLimit(const CredentialCondition *limit); ResultCode QueryCredentialUserId(uint64_t credentialId, int32_t *userId); diff --git a/user_auth/hdi_service/database/src/idm_database.c b/user_auth/hdi_service/database/src/idm_database.c index 8f80cea6b5..d7a29c4368 100644 --- a/user_auth/hdi_service/database/src/idm_database.c +++ b/user_auth/hdi_service/database/src/idm_database.c @@ -245,6 +245,32 @@ IAM_STATIC UserInfo *QueryUserInfo(int32_t userId) return NULL; } +ResultCode SetHasSuccessPinAuth(int32_t userId, bool hasSuccessPinAuth) +{ + UserInfo *user = QueryUserInfo(userId); + if (user == NULL) { + LOG_ERROR("can't find this user"); + return RESULT_NOT_FOUND; + } + user->hasSuccessPinAuth = hasSuccessPinAuth; + return RESULT_SUCCESS; +} + +ResultCode GetHasSuccessPinAuth(int32_t userId, bool *hasSuccessPinAuth) +{ + if (hasSuccessPinAuth == NULL) { + LOG_ERROR("bad param"); + return RESULT_BAD_PARAM; + } + UserInfo *user = QueryUserInfo(userId); + if (user == NULL) { + LOG_ERROR("can't find this user"); + return RESULT_NOT_FOUND; + } + *hasSuccessPinAuth = user->hasSuccessPinAuth; + return RESULT_SUCCESS; +} + IAM_STATIC ResultCode GetAllEnrolledInfoFromUser(UserInfo *userInfo, EnrolledInfoHal **enrolledInfos, uint32_t *num) { LinkedList *enrolledInfoList = userInfo->enrolledInfoList; diff --git a/user_auth/hdi_service/service/user_auth_interface_service.cpp b/user_auth/hdi_service/service/user_auth_interface_service.cpp index cea607d5fc..1d8eb444bb 100644 --- a/user_auth/hdi_service/service/user_auth_interface_service.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_service.cpp @@ -498,6 +498,21 @@ static int32_t CopyAuthParamToHal(uint64_t contextId, const HdiAuthParam ¶m, return RESULT_SUCCESS; } +static int32_t CheckFirstAuthType(int32_t userId, uint32_t authType) +{ + bool hasSuccessPinAuth = false; + ResultCode ret = GetHasSuccessPinAuth(userId, &hasSuccessPinAuth); + if (ret != RESULT_SUCCESS) { + LOG_ERROR("GetHasSuccessPinAuth failed"); + return ret; + } + if (hasSuccessPinAuth == false && authType != PIN_AUTH) { + LOG_ERROR("first auth type must be pinAuth"); + return RESULT_TYPE_NOT_SUPPORT; + } + return RESULT_SUCCESS; +} + int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const HdiAuthParam ¶m, std::vector &infos) { @@ -520,6 +535,11 @@ int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const IAM_LOGE("get null schedule"); return RESULT_GENERAL_ERROR; } + ret = CheckFirstAuthType(paramHal.userId, paramHal.authType); + if (ret != RESULT_SUCCESS) { + DestroyLinkedList(schedulesGet); + return ret; + } LinkedListNode *tempNode = schedulesGet->head; while (tempNode != nullptr) { if (tempNode->data == nullptr) { diff --git a/user_auth/hdi_service/user_auth/src/user_auth_funcs.c b/user_auth/hdi_service/user_auth/src/user_auth_funcs.c index f94e474fb9..c46f0a154b 100644 --- a/user_auth/hdi_service/user_auth/src/user_auth_funcs.c +++ b/user_auth/hdi_service/user_auth/src/user_auth_funcs.c @@ -132,6 +132,18 @@ IAM_STATIC ResultCode HandleAuthSuccessResult(const UserAuthContext *context, co result->credentialDigest = enrolledState.credentialDigest; result->credentialCount = enrolledState.credentialCount; } + if (result->result == RESULT_SUCCESS && context->authType == PIN_AUTH) { + bool hasSuccessPinAuth = false; + ResultCode ret = GetHasSuccessPinAuth(context->userId, &hasSuccessPinAuth); + if (ret != RESULT_SUCCESS) { + LOG_ERROR("GetHasSuccessPinAuth failed"); + return ret; + } + if (hasSuccessPinAuth == false) { + LOG_INFO("hasSuccessPinAuth: %d", hasSuccessPinAuth); + SetHasSuccessPinAuth(context->userId, true); + } + } if (result->result == RESULT_SUCCESS && context->authType == PIN_AUTH && memcmp(context->localUdid, context->collectorUdid, sizeof(context->localUdid)) == 0) { result->rootSecret = CopyBuffer(info->rootSecret); -- Gitee From 6cc9e84e890813e268560601e09c383429490ab5 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 10:08:46 +0800 Subject: [PATCH 0061/1485] DTS2024080517757 wpa_host Signed-off-by: xionglei --- wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c | 1 + wlan/test/unittest/chip/wifi_ap_iface_test.cpp | 1 + wlan/test/unittest/chip/wifi_p2p_iface_test.cpp | 1 + wlan/test/unittest/chip/wifi_sta_iface_test.cpp | 1 + wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c | 1 + 5 files changed, 5 insertions(+) diff --git a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c index 46672da591..65a2a00f26 100644 --- a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c +++ b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c @@ -25,6 +25,7 @@ #include "v1_0/ihostapd_interface.h" #include "hostapd_impl.h" + struct HdfHostapdInterfaceHost { struct IDeviceIoService ioService; struct IHostapdInterface *service; diff --git a/wlan/test/unittest/chip/wifi_ap_iface_test.cpp b/wlan/test/unittest/chip/wifi_ap_iface_test.cpp index 0baeae9a57..e88a4576bc 100644 --- a/wlan/test/unittest/chip/wifi_ap_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_ap_iface_test.cpp @@ -21,6 +21,7 @@ using namespace testing::ext; using namespace OHOS::HDI::Wlan::Chip::V1_0; + namespace WifiApIfaceTest { const std::string AP_IFNAME = "wlan1"; const std::string TEST_MAC = "000000"; diff --git a/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp b/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp index 6d772c9222..c0462d6b2b 100644 --- a/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp @@ -24,6 +24,7 @@ namespace WifiP2pIfaceTest { const std::string P2P_IFNAME = "P2P0"; const std::string TEST_MAC = "000000"; + class WifiP2pIfaceTest : public testing::Test { public: static void SetUpTestCase() {} diff --git a/wlan/test/unittest/chip/wifi_sta_iface_test.cpp b/wlan/test/unittest/chip/wifi_sta_iface_test.cpp index 4f2364158c..2c0b2cc4e3 100644 --- a/wlan/test/unittest/chip/wifi_sta_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_sta_iface_test.cpp @@ -26,6 +26,7 @@ const std::string WLAN_IFNAME = "wlan0"; const std::string AP_IFNAME = "wlan1"; const std::string TEST_MAC = "000000"; + class WifiStaIfaceTest : public testing::Test { public: static void SetUpTestCase() {} diff --git a/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c b/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c index 634898cc16..eff02bb057 100644 --- a/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c +++ b/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c @@ -30,6 +30,7 @@ struct HdfWpaInterfaceHost { struct HdfRemoteService **stubObject; }; + static int32_t WpaInterfaceDriverDispatch( struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { -- Gitee From 6d0b7e5900ba1202773f6560d1700437af443a45 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 02:22:22 +0000 Subject: [PATCH 0062/1485] update wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c. Signed-off-by: xionglei --- .../hdi_service/hostapd_interface_drivers.c | 25 +++++++++++++------ 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c index 65a2a00f26..e79583fc95 100644 --- a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c +++ b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -25,30 +26,37 @@ #include "v1_0/ihostapd_interface.h" #include "hostapd_impl.h" - struct HdfHostapdInterfaceHost { struct IDeviceIoService ioService; struct IHostapdInterface *service; struct HdfRemoteService **stubObject; }; +static pthread_rwlock_t g_rwLock = PTHREAD_RWLOCK_INITIALIZER; +static int g_stop = 0; + static int32_t HostapdInterfaceDriverDispatch( struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { HDF_LOGI("HostapdInterfaceDriverDispatch enter."); + pthread_rwlock_rdlock(&g_rwLock); struct HdfHostapdInterfaceHost *hostapdinterfaceHost = CONTAINER_OF( client->device->service, struct HdfHostapdInterfaceHost, ioService); - if (hostapdinterfaceHost->service == NULL || hostapdinterfaceHost->stubObject == NULL) { + if (g_stop == 1 || hostapdinterfaceHost->service == NULL || hostapdinterfaceHost->stubObject == NULL) { HDF_LOGE("%{public}s: invalid service obj", __func__); + pthread_rwlock_unlock(&g_rwLock); return HDF_ERR_INVALID_OBJECT; } struct HdfRemoteService *stubObj = *hostapdinterfaceHost->stubObject; if (stubObj == NULL || stubObj->dispatcher == NULL || stubObj->dispatcher->Dispatch == NULL) { + pthread_rwlock_unlock(&g_rwLock); return HDF_ERR_INVALID_OBJECT; } - return stubObj->dispatcher->Dispatch((struct HdfRemoteService *)stubObj->target, cmdId, data, reply); + int ret = stubObj->dispatcher->Dispatch((struct HdfRemoteService *)stubObj->target, cmdId, data, reply); + pthread_rwlock_unlock(&g_rwLock); + return ret; } static int HdfHostapdInterfaceDriverInit(struct HdfDeviceObject *deviceObject) @@ -105,6 +113,8 @@ static void HdfHostapdInterfaceDriverRelease(struct HdfDeviceObject *deviceObjec HDF_LOGI("HdfHostapdInterfaceDriverRelease enter."); struct HdfHostapdRemoteNode *pos = NULL; struct HdfHostapdRemoteNode *tmp = NULL; + pthread_rwlock_wrlock(&g_rwLock); + g_stop = 1; struct HdfHostapdStubData *stubData = HdfHostapdStubDriver(); if (stubData == NULL) { HDF_LOGE("%{public}s: stubData is NUll!", __func__); @@ -120,10 +130,11 @@ static void HdfHostapdInterfaceDriverRelease(struct HdfDeviceObject *deviceObjec OsalMutexDestroy(&stubData->mutex); struct HdfHostapdInterfaceHost *hostapdinterfaceHost = CONTAINER_OF( deviceObject->service, struct HdfHostapdInterfaceHost, ioService); - StubCollectorRemoveObject(IHOSTAPDINTERFACE_INTERFACE_DESC, hostapdinterfaceHost->service); - IHostapdInterfaceRelease(hostapdinterfaceHost->service, true); - OsalMemFree(hostapdinterfaceHost); - hostapdinterfaceHost = NULL; + StubCollectorRemoveObject(IHOSTAPDINTERFACE_INTERFACE_DESC, hostapdinterfaceHost->service); + IHostapdInterfaceRelease(hostapdinterfaceHost->service, true); + OsalMemFree(hostapdinterfaceHost); + hostapdinterfaceHost = NULL; + pthread_rwlock_unlock(&g_rwLock); } struct HdfDriverEntry g_hostapdinterfaceDriverEntry = { -- Gitee From 6504e47331a400db02cb31217f16902e21beeb82 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 02:24:30 +0000 Subject: [PATCH 0063/1485] update wlan/test/unittest/chip/wifi_ap_iface_test.cpp. Signed-off-by: xionglei --- wlan/test/unittest/chip/wifi_ap_iface_test.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/wlan/test/unittest/chip/wifi_ap_iface_test.cpp b/wlan/test/unittest/chip/wifi_ap_iface_test.cpp index e88a4576bc..e63c06ec85 100644 --- a/wlan/test/unittest/chip/wifi_ap_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_ap_iface_test.cpp @@ -21,7 +21,6 @@ using namespace testing::ext; using namespace OHOS::HDI::Wlan::Chip::V1_0; - namespace WifiApIfaceTest { const std::string AP_IFNAME = "wlan1"; const std::string TEST_MAC = "000000"; @@ -48,10 +47,6 @@ public: wifiVendorHalTest.reset(); ifaceTool.reset(); ifaceUtil.reset(); - delete apIface; - if (apIface != nullptr) { - apIface = nullptr; - } } public: @@ -187,7 +182,7 @@ HWTEST_F(WifiApIfaceTest, GetSupportFreqsTest, TestSize.Level1) } std::vector freqs; EXPECT_TRUE(apIface->GetSupportFreqs(0, freqs) == HDF_SUCCESS); - EXPECT_TRUE(apIface->SetMacAddress(TEST_MAC) != HDF_SUCCESS); + EXPECT_TRUE(apIface->SetMacAddress(TEST_MAC) == HDF_SUCCESS); EXPECT_TRUE(apIface->SetCountryCode("cn") == HDF_SUCCESS); EXPECT_TRUE(apIface->SetPowerMode(0) == HDF_SUCCESS); int32_t mode; -- Gitee From 7c885ebe0eb0fba23c0f7ffb466b0ddad6144a94 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 02:26:34 +0000 Subject: [PATCH 0064/1485] update wlan/test/unittest/chip/wifi_p2p_iface_test.cpp. Signed-off-by: xionglei --- wlan/test/unittest/chip/wifi_p2p_iface_test.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp b/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp index c0462d6b2b..731fafbcb9 100644 --- a/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_p2p_iface_test.cpp @@ -24,7 +24,6 @@ namespace WifiP2pIfaceTest { const std::string P2P_IFNAME = "P2P0"; const std::string TEST_MAC = "000000"; - class WifiP2pIfaceTest : public testing::Test { public: static void SetUpTestCase() {} @@ -43,10 +42,7 @@ public: } void TearDown() { - delete p2pIface; - if (p2pIface != nullptr) { - p2pIface = nullptr; - } + HDF_LOGE("iface teardown"); } public: -- Gitee From b795d9237e0744252e8799d51ab76254d2399273 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 02:27:40 +0000 Subject: [PATCH 0065/1485] update wlan/test/unittest/chip/wifi_sta_iface_test.cpp. Signed-off-by: xionglei --- wlan/test/unittest/chip/wifi_sta_iface_test.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/wlan/test/unittest/chip/wifi_sta_iface_test.cpp b/wlan/test/unittest/chip/wifi_sta_iface_test.cpp index 2c0b2cc4e3..7383a97352 100644 --- a/wlan/test/unittest/chip/wifi_sta_iface_test.cpp +++ b/wlan/test/unittest/chip/wifi_sta_iface_test.cpp @@ -26,7 +26,6 @@ const std::string WLAN_IFNAME = "wlan0"; const std::string AP_IFNAME = "wlan1"; const std::string TEST_MAC = "000000"; - class WifiStaIfaceTest : public testing::Test { public: static void SetUpTestCase() {} @@ -47,14 +46,6 @@ public: wifiVendorHalTest.reset(); ifaceTool.reset(); ifaceUtil.reset(); - delete staIface; - if (staIface != nullptr) { - staIface = nullptr; - } - delete testIface; - if (testIface != nullptr) { - testIface = nullptr; - } } public: -- Gitee From 9864f8d93dda808fcf2c36fe705d8818fb5b0b68 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 02:36:31 +0000 Subject: [PATCH 0066/1485] update wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c. Signed-off-by: xionglei --- .../hdi_service/wpa_interface_drivers.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c b/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c index eff02bb057..58e55b3421 100644 --- a/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c +++ b/wlan/wpa/interfaces/hdi_service/wpa_interface_drivers.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -30,24 +31,30 @@ struct HdfWpaInterfaceHost { struct HdfRemoteService **stubObject; }; +static pthread_rwlock_t g_rwLock = PTHREAD_RWLOCK_INITIALIZER; +static int g_stop = 0; static int32_t WpaInterfaceDriverDispatch( struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { HDF_LOGI("WpaInterfaceDriverDispatch enter."); + pthread_rwlock_rdlock(&g_rwLock); struct HdfWpaInterfaceHost *wpainterfaceHost = CONTAINER_OF( client->device->service, struct HdfWpaInterfaceHost, ioService); - if (wpainterfaceHost->service == NULL || wpainterfaceHost->stubObject == NULL) { + if (g_stop == 1 || wpainterfaceHost->service == NULL || wpainterfaceHost->stubObject == NULL) { HDF_LOGE("%{public}s: invalid service obj", __func__); + pthread_rwlock_unlock(&g_rwLock); return HDF_ERR_INVALID_OBJECT; } struct HdfRemoteService *stubObj = *wpainterfaceHost->stubObject; if (stubObj == NULL || stubObj->dispatcher == NULL || stubObj->dispatcher->Dispatch == NULL) { + pthread_rwlock_unlock(&g_rwLock); return HDF_ERR_INVALID_OBJECT; } - - return stubObj->dispatcher->Dispatch((struct HdfRemoteService *)stubObj->target, cmdId, data, reply); + int ret = stubObj->dispatcher->Dispatch((struct HdfRemoteService *)stubObj->target, cmdId, data, reply); + pthread_rwlock_unlock(&g_rwLock); + return ret; } static int HdfWpaInterfaceDriverInit(struct HdfDeviceObject *deviceObject) @@ -104,9 +111,12 @@ static void HdfWpaInterfaceDriverRelease(struct HdfDeviceObject *deviceObject) HDF_LOGI("HdfWpaInterfaceDriverRelease enter."); struct HdfWpaRemoteNode *pos = NULL; struct HdfWpaRemoteNode *tmp = NULL; + pthread_rwlock_wrlock(&g_rwLock); + g_stop = 1; struct HdfWpaStubData *stubData = HdfWpaStubDriver(); if (stubData == NULL) { HDF_LOGE("%{public}s: stubData is NUll!", __func__); + pthread_rwlock_unlock(&g_rwLock); return; } @@ -122,6 +132,7 @@ static void HdfWpaInterfaceDriverRelease(struct HdfDeviceObject *deviceObject) IWpaInterfaceRelease(wpainterfaceHost->service, true); OsalMemFree(wpainterfaceHost); wpainterfaceHost = NULL; + pthread_rwlock_unlock(&g_rwLock); } struct HdfDriverEntry g_wpainterfaceDriverEntry = { -- Gitee From 628d7e2ad03af251e77e01fb8ecce31686d92542 Mon Sep 17 00:00:00 2001 From: xwx1135370 Date: Thu, 25 Jul 2024 09:13:15 +0800 Subject: [PATCH 0067/1485] fix: the musl feature configured in part_comfig MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit issue：https://gitee.com/openharmony/third_party_musl/issues/IAF1XE?from=project-issue Test：Source code compilation Signed-off-by: xwx1135370 --- audio/hdi_service/primary_impl/BUILD.gn | 2 +- codec/hal/BUILD.gn | 6 +++--- codec/hal/idl_service/BUILD.gn | 2 +- intelligent_voice/hdi_service/trigger/BUILD.gn | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index d9ecfddee3..644d6826aa 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -59,7 +59,7 @@ ohos_shared_library("audio_primary_impl_vendor") { defines += [ "AUDIO_HDF_LOG" ] } - if (use_jemalloc && use_jemalloc_dfx_intf) { + if (musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } diff --git a/codec/hal/BUILD.gn b/codec/hal/BUILD.gn index 7b0b3830a0..bc1fb81d37 100644 --- a/codec/hal/BUILD.gn +++ b/codec/hal/BUILD.gn @@ -72,7 +72,7 @@ ohos_shared_library("libcodec_hdi_omx_server") { defines += [ "SUPPORT_ROLE" ] } if (use_musl) { - if (use_jemalloc && use_jemalloc_dfx_intf) { + if (musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } } @@ -132,7 +132,7 @@ ohos_static_library("libcodec_hdi_omx_server_static") { defines += [ "SUPPORT_ROLE" ] } if (use_musl) { - if (use_jemalloc && use_jemalloc_dfx_intf) { + if (musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } } @@ -169,7 +169,7 @@ ohos_shared_library("libcodec_hdi_omx_client") { external_deps += [ "openmax:libopenmax_static" ] defines = [ "LOG_TAG_HDI_CLIENT" ] if (use_musl) { - if (use_jemalloc && use_jemalloc_dfx_intf) { + if (musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } } diff --git a/codec/hal/idl_service/BUILD.gn b/codec/hal/idl_service/BUILD.gn index ae6d668b6d..d3d0c46201 100644 --- a/codec/hal/idl_service/BUILD.gn +++ b/codec/hal/idl_service/BUILD.gn @@ -61,7 +61,7 @@ ohos_shared_library("libcodec_component_manager_service_3.0") { if (drivers_peripheral_codec_feature_set_omx_role) { defines += [ "SUPPORT_ROLE" ] } - if (use_musl && use_jemalloc && use_jemalloc_dfx_intf) { + if (use_musl && musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } innerapi_tags = [ "passthrough_indirect" ] diff --git a/intelligent_voice/hdi_service/trigger/BUILD.gn b/intelligent_voice/hdi_service/trigger/BUILD.gn index 9ff158fe67..2eb8ef65ad 100644 --- a/intelligent_voice/hdi_service/trigger/BUILD.gn +++ b/intelligent_voice/hdi_service/trigger/BUILD.gn @@ -28,7 +28,7 @@ ohos_shared_library("intell_voice_trigger_manager_service_1.1") { defines = [] if (use_musl) { - if (use_jemalloc && use_jemalloc_dfx_intf) { + if (musl_use_jemalloc && musl_use_jemalloc_dfx_intf) { defines += [ "CONFIG_USE_JEMALLOC_DFX_INTF" ] } } -- Gitee From 9e742c4e7bdf04ce7d717bdc1c94a56ba7c170ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 6 Aug 2024 11:45:54 +0800 Subject: [PATCH 0068/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- display/composer/test/benchmark/display_benchmark_test.cpp | 2 +- display/composer/test/common/hdi_test_device.cpp | 2 +- display/composer/test/common/hdi_test_device.h | 4 ++-- display/composer/test/common/hdi_test_display.cpp | 2 +- display/composer/test/common/hdi_test_display.h | 4 ++-- .../composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp | 4 ++-- display/composer/test/fuzztest/layer_fuzzer/layer_fuzzer.cpp | 4 ++-- display/composer/test/unittest/hdi_composer_ut.cpp | 3 +-- display/composer/test/unittest/hdi_death_test.cpp | 4 ++-- 9 files changed, 14 insertions(+), 15 deletions(-) diff --git a/display/composer/test/benchmark/display_benchmark_test.cpp b/display/composer/test/benchmark/display_benchmark_test.cpp index 7631b820fc..f8c889b652 100644 --- a/display/composer/test/benchmark/display_benchmark_test.cpp +++ b/display/composer/test/benchmark/display_benchmark_test.cpp @@ -36,7 +36,7 @@ using namespace OHOS::HDI::Display::Composer::V1_1; using namespace OHOS::HDI::Display::TEST; using namespace testing::ext; -static sptr g_composerDevice = nullptr; +static sptr g_composerDevice = nullptr; static std::shared_ptr g_gralloc = nullptr; static std::vector g_displayIds; diff --git a/display/composer/test/common/hdi_test_device.cpp b/display/composer/test/common/hdi_test_device.cpp index 5b68536bb2..ced9cb444a 100644 --- a/display/composer/test/common/hdi_test_device.cpp +++ b/display/composer/test/common/hdi_test_device.cpp @@ -43,7 +43,7 @@ void HdiTestDevice::HotPlug(uint32_t outputId, bool connected, void* data) int32_t HdiTestDevice::InitDevice() { - displayDevice_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayDevice_ = Composer::V1_2::IDisplayComposerInterface::Get(); DISPLAY_TEST_CHK_RETURN((displayDevice_ == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("get IDisplayComposerInterface failed")); diff --git a/display/composer/test/common/hdi_test_device.h b/display/composer/test/common/hdi_test_device.h index ecd95f8268..debf8fc22a 100644 --- a/display/composer/test/common/hdi_test_device.h +++ b/display/composer/test/common/hdi_test_device.h @@ -42,7 +42,7 @@ public: return gralloc_; } - sptr &GetDeviceInterface() + sptr &GetDeviceInterface() { return displayDevice_; } @@ -55,7 +55,7 @@ private: std::shared_ptr FindDisplayOrCreate(uint32_t id); std::map> displays_; - sptr displayDevice_; + sptr displayDevice_; std::shared_ptr gralloc_ = nullptr; std::vector displayIds_; }; diff --git a/display/composer/test/common/hdi_test_display.cpp b/display/composer/test/common/hdi_test_display.cpp index 72f6e76b22..d5cc4455c1 100644 --- a/display/composer/test/common/hdi_test_display.cpp +++ b/display/composer/test/common/hdi_test_display.cpp @@ -22,7 +22,7 @@ namespace HDI { namespace Display { namespace TEST { using namespace OHOS::HDI::Display::Composer::V1_1; -HdiTestDisplay::HdiTestDisplay(uint32_t id, sptr device) +HdiTestDisplay::HdiTestDisplay(uint32_t id, sptr device) : id_(id), device_(device), currentFb_(nullptr) { } diff --git a/display/composer/test/common/hdi_test_display.h b/display/composer/test/common/hdi_test_display.h index 0bb89aa508..f088409cc2 100644 --- a/display/composer/test/common/hdi_test_display.h +++ b/display/composer/test/common/hdi_test_display.h @@ -30,7 +30,7 @@ namespace TEST { using namespace OHOS::HDI::Display::Composer::V1_1; class HdiTestDisplay { public: - HdiTestDisplay(uint32_t id, sptr device); + HdiTestDisplay(uint32_t id, sptr device); virtual ~HdiTestDisplay() {} int32_t Init(); int32_t GetModeInfoFromId(int32_t id, DisplayModeInfo& modeInfo) const; @@ -65,7 +65,7 @@ private: uint32_t activeModeId_ = 0; DisplayModeInfo currentMode_ = { 0 }; uint32_t id_; - sptr device_; + sptr device_; DisplayCapability cap_; std::vector modes_; diff --git a/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp b/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp index 3a4a28cd29..bffabe398e 100644 --- a/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp +++ b/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp @@ -26,7 +26,7 @@ namespace OHOS { using namespace OHOS::HDI::Display::Buffer::V1_0; using namespace OHOS::HDI::Display::Composer::V1_1; -static sptr g_composerInterface = nullptr; +static sptr g_composerInterface = nullptr; static std::shared_ptr g_bufferInterface = nullptr; static bool g_isInit = false; @@ -485,7 +485,7 @@ bool FuzzTest(const uint8_t* rawData, size_t size) // initialize service if (!g_isInit) { g_isInit = true; - g_composerInterface = Composer::V1_1::IDisplayComposerInterface::Get(); + g_composerInterface = Composer::V1_2::IDisplayComposerInterface::Get(); if (g_composerInterface == nullptr) { HDF_LOGE("%{public}s: get IDisplayComposerInterface failed", __func__); return false; diff --git a/display/composer/test/fuzztest/layer_fuzzer/layer_fuzzer.cpp b/display/composer/test/fuzztest/layer_fuzzer/layer_fuzzer.cpp index 210ad64d96..f2f40ab812 100644 --- a/display/composer/test/fuzztest/layer_fuzzer/layer_fuzzer.cpp +++ b/display/composer/test/fuzztest/layer_fuzzer/layer_fuzzer.cpp @@ -25,7 +25,7 @@ namespace OHOS { using namespace OHOS::HDI::Display::Buffer::V1_0; using namespace OHOS::HDI::Display::Composer::V1_1; -static sptr g_composerInterface = nullptr; +static sptr g_composerInterface = nullptr; static std::shared_ptr g_bufferInterface = nullptr; static bool g_isInit = false; @@ -393,7 +393,7 @@ bool FuzzTest(const uint8_t* rawData, size_t size) if (!g_isInit) { g_isInit = true; - g_composerInterface = Composer::V1_1::IDisplayComposerInterface::Get(); + g_composerInterface = Composer::V1_2::IDisplayComposerInterface::Get(); if (g_composerInterface == nullptr) { HDF_LOGE("%{public}s: get IDisplayComposerInterface failed", __func__); return false; diff --git a/display/composer/test/unittest/hdi_composer_ut.cpp b/display/composer/test/unittest/hdi_composer_ut.cpp index 18e7009ee9..7667bc7921 100644 --- a/display/composer/test/unittest/hdi_composer_ut.cpp +++ b/display/composer/test/unittest/hdi_composer_ut.cpp @@ -18,7 +18,6 @@ #include #include #include "v1_2/include/idisplay_composer_interface.h" -#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" @@ -37,7 +36,7 @@ using namespace OHOS::HDI::Display::Composer::V1_1; using namespace OHOS::HDI::Display::TEST; using namespace testing::ext; -static sptr g_composerDevice = nullptr; +static sptr g_composerDevice = nullptr; static std::shared_ptr g_gralloc = nullptr; static std::vector g_displayIds; const int SLEEP_CONT_10 = 10; diff --git a/display/composer/test/unittest/hdi_death_test.cpp b/display/composer/test/unittest/hdi_death_test.cpp index 8e7ad33016..feb52a3fad 100644 --- a/display/composer/test/unittest/hdi_death_test.cpp +++ b/display/composer/test/unittest/hdi_death_test.cpp @@ -39,7 +39,7 @@ void ComposerDiedRecipient::OnRemoteDied(const wptr& remote) HWTEST_F(DeathTest, test_AddDeathRecipient, TestSize.Level1) { - displayComposer_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayComposer_ = Composer::V1_2::IDisplayComposerInterface::Get(); ASSERT_TRUE(displayComposer_ != nullptr); sptr recipient = new ComposerDiedRecipient(); ASSERT_TRUE(recipient != nullptr); @@ -51,7 +51,7 @@ HWTEST_F(DeathTest, test_AddDeathRecipient, TestSize.Level1) HWTEST_F(DeathTest, test_RemoveDeathRecipient, TestSize.Level1) { - displayComposer_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayComposer_ = Composer::V1_2::IDisplayComposerInterface::Get(); ASSERT_TRUE(displayComposer_ != nullptr); sptr recipient = new ComposerDiedRecipient(); ASSERT_TRUE(recipient != nullptr); -- Gitee From 2d143b7493218ce1de55d1ce6b8ee740aec80c99 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 6 Aug 2024 06:09:11 +0000 Subject: [PATCH 0069/1485] update wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c. Signed-off-by: xionglei --- wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c index e79583fc95..05ea4196bb 100644 --- a/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c +++ b/wlan/hostapd/interfaces/hdi_service/hostapd_interface_drivers.c @@ -118,6 +118,7 @@ static void HdfHostapdInterfaceDriverRelease(struct HdfDeviceObject *deviceObjec struct HdfHostapdStubData *stubData = HdfHostapdStubDriver(); if (stubData == NULL) { HDF_LOGE("%{public}s: stubData is NUll!", __func__); + pthread_rwlock_unlock(&g_rwLock); return; } -- Gitee From 23f1e9210792a31aee35527da62e9f745d105465 Mon Sep 17 00:00:00 2001 From: liangqi Date: Thu, 1 Aug 2024 16:54:57 +0800 Subject: [PATCH 0070/1485] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liangqi --- input/test/BUILD.gn | 5 +- .../hdi_passthrough_additional/BUILD.gn | 58 + .../hdf_input_hdi_test.cpp | 1550 +++++++++++++++++ .../input_callback_impl.cpp | 80 + .../input_callback_impl.h | 41 + 5 files changed, 1733 insertions(+), 1 deletion(-) create mode 100644 input/test/unittest/hdi_passthrough_additional/BUILD.gn create mode 100644 input/test/unittest/hdi_passthrough_additional/hdf_input_hdi_test.cpp create mode 100644 input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp create mode 100644 input/test/unittest/hdi_passthrough_additional/input_callback_impl.h diff --git a/input/test/BUILD.gn b/input/test/BUILD.gn index e910036534..1deb9d398b 100644 --- a/input/test/BUILD.gn +++ b/input/test/BUILD.gn @@ -34,7 +34,10 @@ if (defined(ohos_lite)) { deps = [ "benchmarktest:hdf_input_benchmark_test" ] if (drivers_peripheral_input_feature_model) { - deps += [ "unittest/hdi:hdi_unittest_input" ] + deps += [ + "unittest/hdi:hdi_unittest_input", + "unittest/hdi_passthrough_additional:InputPassthroughAdditionalTest", + ] } if (drivers_peripheral_input_feature_udriver) { deps += [ "unittest/udriver:input_udriver_unittest" ] diff --git a/input/test/unittest/hdi_passthrough_additional/BUILD.gn b/input/test/unittest/hdi_passthrough_additional/BUILD.gn new file mode 100644 index 0000000000..c27c1cd6e5 --- /dev/null +++ b/input/test/unittest/hdi_passthrough_additional/BUILD.gn @@ -0,0 +1,58 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") + +module_output_path = "drivers_peripheral_input/input" +INPUT_ROOT_DIR = "./../../.." + +ohos_unittest("InputPassthroughAdditionalTest") { + module_out_path = module_output_path + configs = [ ":hdf_input_through_additional" ] + + sources = [ + "hdf_input_hdi_test.cpp", + "input_callback_impl.cpp", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + + if (is_standard_system) { + external_deps = [ + "c_utils:utils", + "drivers_interface_input:libinput_proxy_1.0", + "hdf_core:libhdf_utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + } else { + external_deps = [ "hilog:libhilog" ] + } + external_deps += [ "ipc:ipc_single" ] +} + +config("hdf_input_through_additional") { + include_dirs = [ + "$INPUT_ROOT_DIR/interfaces/include", + "$INPUT_ROOT_DIR/interfaces", + "//third_party/FreeBSD/sys/dev/evdev", + "$INPUT_ROOT_DIR/hdi_service", + ] +} diff --git a/input/test/unittest/hdi_passthrough_additional/hdf_input_hdi_test.cpp b/input/test/unittest/hdi_passthrough_additional/hdf_input_hdi_test.cpp new file mode 100644 index 0000000000..a17beb236a --- /dev/null +++ b/input/test/unittest/hdi_passthrough_additional/hdf_input_hdi_test.cpp @@ -0,0 +1,1550 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "osal_time.h" +#include "v1_0/iinput_interfaces.h" +#include "input_type.h" +#include "input_callback_impl.h" + +using namespace OHOS::HDI::Input::V1_0; +using namespace testing::ext; + +namespace { +sptr g_inputInterfaces = nullptr; +sptr g_callback = nullptr; +sptr g_hotplugCb = nullptr; +constexpr int32_t TOUCH_INDEX = 1; +constexpr int32_t MAX_DEVICES = 33; +constexpr int32_t INIT_DEFAULT_VALUE = 255; +constexpr int32_t TEST_RESULT_LEN = 32; +std::vector g_sta; +} // namespace + +class HdfInputHdiTestAdditional : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfInputHdiTestAdditional::SetUpTestCase() +{ + g_inputInterfaces = IInputInterfaces::Get(true); + if (g_inputInterfaces != nullptr) { + g_callback = new InputCallbackImpl(g_inputInterfaces, nullptr); + g_hotplugCb = new InputCallbackImpl(g_inputInterfaces, g_callback); + g_inputInterfaces->ScanInputDevice(g_sta); + } +} + +void HdfInputHdiTestAdditional::TearDownTestCase() {} + +void HdfInputHdiTestAdditional::SetUp() {} + +void HdfInputHdiTestAdditional::TearDown() {} + +static bool IsOnlineDev(uint32_t devIndex) +{ + bool ret = false; + int32_t i = 0; + for (i = 0; i < g_sta.size(); i++) { + if (g_sta[i].devIndex == devIndex) { + ret = true; + break; + } + } + return ret; +} + +/** + * @tc.number : SUB_Driver_Input_ScanInputDevice_0200 + * @tc.name : testScanInputDevice001 + * @tc.desc : Reliability of function(ScanInputDevice) + */ +HWTEST_F(HdfInputHdiTestAdditional, testScanInputDevice001, Function | MediumTest | Level1) +{ + std::vector sta; + int32_t ret = 0; + int i = 0; + for (i = 0; i < 1000; i++) { + ret |= g_inputInterfaces->ScanInputDevice(sta); + } + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_OpenInputDevice_0300 + * @tc.name : testOpenInputDevice001 + * @tc.desc : Reliability of function(OpenInputDevice) + */ +HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + for (i = 0; i < 1000; i++) { + ret |= g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + } + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_OpenInputDevice_0400 + * @tc.name : testOpenInputDevice002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_OpenInputDevice_0500 + * @tc.name : testOpenInputDevice003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_OpenInputDevice_0600 + * @tc.name : testOpenInputDevice004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice004, Function | MediumTest | Level2) +{ + int32_t ret = g_inputInterfaces->OpenInputDevice(MAX_DEVICES); + g_inputInterfaces->CloseInputDevice(MAX_DEVICES); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_CloseInputDevice_0300 + * @tc.name : testCloseInputDevice001 + * @tc.desc : Reliability of function(CloseInputDevice) + */ +HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + for (i = 0; i < 1000; i++) { + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + if (ret != INPUT_SUCCESS) { + break; + } + ret |= g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + } + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_CloseInputDevice_0400 + * @tc.name : testCloseInputDevice002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_CloseInputDevice_0500 + * @tc.name : testCloseInputDevice003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_CloseInputDevice_0600 + * @tc.name : testCloseInputDevice004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + ret = g_inputInterfaces->CloseInputDevice(MAX_DEVICES); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetInputDevice_0300 + * @tc.name : testGetInputDevice001 + * @tc.desc : Reliability of function(GetInputDevice) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice001, Function | MediumTest | Level1) +{ + struct DeviceInfo devInfo; + int32_t ret = 0; + int i = 0; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + ret |= g_inputInterfaces->GetInputDevice(TOUCH_INDEX, devInfo); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetInputDevice_0400 + * @tc.name : testGetInputDevice002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice002, Function | MediumTest | Level2) +{ + struct DeviceInfo devInfo; + int32_t ret = 0; + uint32_t devIndex = 0; + ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetInputDevice_0500 + * @tc.name : testGetInputDevice003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice003, Function | MediumTest | Level1) +{ + struct DeviceInfo devInfo; + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo); + EXPECT_EQ(ret, INPUT_SUCCESS); + g_inputInterfaces->CloseInputDevice(devIndex); + } else { + ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetInputDevice_0600 + * @tc.name : testGetInputDevice004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice004, Function | MediumTest | Level2) +{ + struct DeviceInfo devInfo; + int32_t ret = g_inputInterfaces->GetInputDevice(MAX_DEVICES, devInfo); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetInputDeviceList_0200 + * @tc.name : testGetInputDeviceList001 + * @tc.desc : Reliability of function(GetInputDeviceList) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetInputDeviceList001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + uint32_t num = 0; + std::vector dev; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + g_inputInterfaces->GetInputDeviceList(num, dev, MAX_INPUT_DEV_NUM); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * + * @tc.number : SUB_Driver_Input_SetPowerStatus_0500 + * @tc.name : testSetPowerStatus001 + * @tc.desc : Reliability of function(SetPowerStatus) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + uint32_t setStatus = INPUT_SUSPEND; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_0600 + * @tc.name : testSetPowerStatus002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + uint32_t setStatus = INPUT_SUSPEND; + ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_0700 + * @tc.name : testSetPowerStatus003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + uint32_t setStatus = INPUT_SUSPEND; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus); + EXPECT_EQ(ret, INPUT_SUCCESS); + g_inputInterfaces->CloseInputDevice(devIndex); + } else { + ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_0800 + * @tc.name : testSetPowerStatus004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t setStatus = INPUT_SUSPEND; + ret = g_inputInterfaces->SetPowerStatus(MAX_DEVICES, setStatus); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_0900 + * @tc.name : testSetPowerStatus005 + * @tc.desc : Test parameters(devIndex::1,setStatus::INPUT_POWER_STATUS_UNKNOWN) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus005, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t setStatus = INPUT_POWER_STATUS_UNKNOWN; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus); + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_1000 + * @tc.name : testSetPowerStatus006 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus006, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t setStatus = INPUT_POWER_STATUS_UNKNOWN; + ret = g_inputInterfaces->SetPowerStatus(MAX_DEVICES, setStatus); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_1100 + * @tc.name : testSetPowerStatus007 + * @tc.desc : Test parameters(devIndex::1,setStatus::5) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus007, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t setStatus = 5; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus); + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetPowerStatus_1200 + * @tc.name : testSetPowerStatus008 + * @tc.desc : Test parameters(devIndex::1,setStatus::0x7fffffff) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus008, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t setStatus = 0x7fffffff; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus); + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetPowerStatus_0300 + * @tc.name : testGetPowerStatus001 + * @tc.desc : Reliability of function(GetPowerStatus) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + uint32_t getStatus = 0; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + ret = g_inputInterfaces->GetPowerStatus(TOUCH_INDEX, getStatus); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetPowerStatus_0400 + * @tc.name : testGetPowerStatus002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + uint32_t getStatus = 0; + ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetPowerStatus_0600 + * @tc.name : testGetPowerStatus004 + * @tc.desc : Test input param(devIndex::3~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus004, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = 3; + uint32_t getStatus = 0; + for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetPowerStatus_0700 + * @tc.name : testGetPowerStatus005 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus005, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t getStatus = 0; + ret = g_inputInterfaces->GetPowerStatus(MAX_DEVICES, getStatus); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetDeviceType_0300 + * @tc.name : testGetDeviceType001 + * @tc.desc : Reliability of function(GetDeviceType) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + int i = 0; + uint32_t devType = INIT_DEFAULT_VALUE; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + ret = g_inputInterfaces->GetDeviceType(TOUCH_INDEX, devType); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetDeviceType_0400 + * @tc.name : testGetDeviceType002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + uint32_t devType = INIT_DEFAULT_VALUE; + ret = g_inputInterfaces->GetDeviceType(devIndex, devType); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetDeviceType_0500 + * @tc.name : testGetDeviceType003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + uint32_t devType = INIT_DEFAULT_VALUE; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetDeviceType(devIndex, devType); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->GetDeviceType(devIndex, devType); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetDeviceType_0600 + * @tc.name : testGetDeviceType004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devType = INIT_DEFAULT_VALUE; + ret = g_inputInterfaces->GetDeviceType(MAX_DEVICES, devType); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0300 + * @tc.name : testSetGestureMode001 + * @tc.desc : Reliability of function(SetGestureMode) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode001, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t gestureMode = 1; + int i = 0; + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + for (i = 0; i < 1000; i++) { + ret = g_inputInterfaces->SetGestureMode(TOUCH_INDEX, gestureMode); + } + g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0400 + * @tc.name : testSetGestureMode002 + * @tc.desc : Test parameters(devIndex::0) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + uint32_t gestureMode = 1; + ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0500 + * @tc.name : testSetGestureMode003 + * @tc.desc : Test input param(devIndex::1~32) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + uint32_t gestureMode = 1; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0600 + * @tc.name : testSetGestureMode004 + * @tc.desc : Test parameters(devIndex::33) with abnormal input + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t gestureMode = 1; + ret = g_inputInterfaces->SetGestureMode(MAX_DEVICES, gestureMode); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0700 + * @tc.name : testSetGestureMode005 + * @tc.desc : Test input param(devIndex::1,gestureMode::0) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode005, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + uint32_t gestureMode = 0; + g_inputInterfaces->OpenInputDevice(devIndex); + ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_SetGestureMode_0800 + * @tc.name : testSetGestureMode006 + * @tc.desc : Test input param(devIndex::1,gestureMode::0x7fffffff) + */ +HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode006, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + uint32_t gestureMode = 0x7fffffff; + g_inputInterfaces->OpenInputDevice(devIndex); + ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode); + g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipInfo_0300 + * @tc.name : testGetChipInfo001 + * @tc.desc : GetChipInfo, stability test + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo001, Function | MediumTest | Level1) +{ + int32_t ret; + + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + + std::string chipInfo; + + for (int i = 0; i < 1000; i++) { + ret = g_inputInterfaces->GetChipInfo(TOUCH_INDEX, chipInfo); + EXPECT_EQ(ret, INPUT_SUCCESS); + } + + ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipInfo_0400 + * @tc.name : testGetChipInfo002 + * @tc.desc : GetChipInfo, Test input param, devIndex = 0 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + std::string chipInfo; + + ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipInfo_0500 + * @tc.name : testGetChipInfo003 + * @tc.desc : GetChipInfo, Test input param + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + std::string chipInfo; + + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetChipInfo_0600 + * @tc.name : testGetChipInfo004 + * @tc.desc : GetChipInfo, Test input param, devIndex = 32 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = MAX_DEVICES; + std::string chipInfo; + + ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetVendorName_0300 + * @tc.name : testGetVendorName001 + * @tc.desc : GetVendorName, stability test + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName001, Function | MediumTest | Level1) +{ + int32_t ret; + + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + + std::string vendorName; + + for (int i = 0; i < 1000; i++) { + ret = g_inputInterfaces->GetVendorName(TOUCH_INDEX, vendorName); + EXPECT_EQ(ret, INPUT_SUCCESS); + } + + ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetVendorName_0400 + * @tc.name : testGetVendorName002 + * @tc.desc : GetVendorName, Test input param, devIndex = 0 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + std::string vendorName; + + ret = g_inputInterfaces->GetVendorName(devIndex, vendorName); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetVendorName_0500 + * @tc.name : testGetVendorName003 + * @tc.desc : GetVendorName, Test input param, devIndex = 2 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + std::string vendorName; + + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetVendorName(devIndex, vendorName); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->GetVendorName(devIndex, vendorName); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetVendorName_0600 + * @tc.name : testGetVendorName004 + * @tc.desc : GetVendorName, Test input param, devIndex = 32 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = MAX_DEVICES; + std::string vendorName; + + ret = g_inputInterfaces->GetVendorName(devIndex, vendorName); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipName_0300 + * @tc.name : testGetChipName001 + * @tc.desc : GetChipName, stability test + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipName001, Function | MediumTest | Level1) +{ + int32_t ret; + + ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); + + std::string chipName; + + for (int i = 0; i < 1000; i++) { + ret = g_inputInterfaces->GetChipName(TOUCH_INDEX, chipName); + EXPECT_EQ(ret, INPUT_SUCCESS); + } + + ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipName_0400 + * @tc.name : testGetChipName002 + * @tc.desc : GetChipName, Test input param, devIndex = 0 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipName002, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = 0; + std::string chipName; + + ret = g_inputInterfaces->GetChipName(devIndex, chipName); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_GetChipName_0500 + * @tc.name : testGetChipName003 + * @tc.desc : GetChipName, Test input param, devIndex = 2 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipName003, Function | MediumTest | Level1) +{ + int32_t ret = 0; + uint32_t devIndex = TOUCH_INDEX; + std::string chipName; + + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->GetChipName(devIndex, chipName); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->GetChipName(devIndex, chipName); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_GetChipName_0600 + * @tc.name : testGetChipName004 + * @tc.desc : GetChipName, Test input param, devIndex = 32 + */ +HWTEST_F(HdfInputHdiTestAdditional, testGetChipName004, Function | MediumTest | Level2) +{ + int32_t ret = 0; + uint32_t devIndex = MAX_DEVICES; + std::string chipName; + + ret = g_inputInterfaces->GetChipName(devIndex, chipName); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0600 + * @tc.name : testRunCapacitanceTest001 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is BASE_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest001, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + uint32_t testType = BASE_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0700 + * @tc.name : testRunCapacitanceTest002 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is + * BASE_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest002, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = BASE_TEST; + std::string result; + for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0800 + * @tc.name : testRunCapacitanceTest003 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is BASE_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest003, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + uint32_t testType = BASE_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0900 + * @tc.name : testRunCapacitanceTest004 + * @tc.desc : Verify the stability of the RunCapacitanceTest function when devIndex is 1 and testType is BASE_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest004, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = BASE_TEST; + std::string result; + for (int32_t i = 0; i < 1000; i++) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1000 + * @tc.name : testRunCapacitanceTest005 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is FULL_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest005, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + uint32_t testType = FULL_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1100 + * @tc.name : testRunCapacitanceTest006 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is + * FULL_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest006, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = FULL_TEST; + std::string result; + for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1200 + * @tc.name : testRunCapacitanceTest007 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is FULL_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest007, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + uint32_t testType = FULL_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1300 + * @tc.name : testRunCapacitanceTest008 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is MMI_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest008, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + uint32_t testType = MMI_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1400 + * @tc.name : testRunCapacitanceTest009 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is + * MMI_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest009, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = MMI_TEST; + std::string result; + for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1500 + * @tc.name : testRunCapacitanceTest010 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is MMI_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest010, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + uint32_t testType = MMI_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1600 + * @tc.name : testRunCapacitanceTest011 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is + * RUNNING_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest011, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + uint32_t testType = RUNNING_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1700 + * @tc.name : testRunCapacitanceTest012 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is + * RUNNING_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest012, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = RUNNING_TEST; + std::string result; + for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1800 + * @tc.name : testRunCapacitanceTest013 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is + * RUNNING_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest013, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + uint32_t testType = RUNNING_TEST; + std::string result; + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1900 + * @tc.name : testRunCapacitanceTest014 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is + * BASE_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest014, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = BASE_TEST; + std::string result; + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2100 + * @tc.name : testRunCapacitanceTest016 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is + * FULL_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest016, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = FULL_TEST; + std::string result; + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2300 + * @tc.name : testRunCapacitanceTest018 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is + * MMI_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest018, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = MMI_TEST; + std::string result; + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2500 + * @tc.name : testRunCapacitanceTest020 + * @tc.desc : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is + * RUNNING_TEST. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest020, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + uint32_t testType = RUNNING_TEST; + std::string result; + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN); + EXPECT_NE(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0300 + * @tc.name : testRunExtraCommand001 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 0. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand001, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = "WakeUpMode"; + extraCmd.cmdValue = "Enable"; + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0400 + * @tc.name : testRunExtraCommand002 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 2. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand002, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = "WakeUpMode"; + extraCmd.cmdValue = "Enable"; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0500 + * @tc.name : testRunExtraCommand003 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 32. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand003, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = "WakeUpMode"; + extraCmd.cmdValue = "Enable"; + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0600 + * @tc.name : testRunExtraCommand004 + * @tc.desc : Verify the stability of the RunExtraCommand function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand004, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = "WakeUpMode"; + extraCmd.cmdValue = "Enable"; + for (int32_t i = 0; i < 1000; i++) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0700 + * @tc.name : testRunExtraCommand005 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand005, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = ""; + extraCmd.cmdValue = ""; + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0800 + * @tc.name : testRunExtraCommand006 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand006, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = ""; + extraCmd.cmdValue = "Enable"; + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RunExtraCommand_0900 + * @tc.name : testRunExtraCommand007 + * @tc.desc : Verify the reliability of the RunExtraCommand function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand007, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + struct ExtraCmd extraCmd; + extraCmd.cmdCode = "WakeUpMode"; + extraCmd.cmdValue = ""; + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RegisterReportCallback_0300 + * @tc.name : testRegisterReportCallback001 + * @tc.desc : Verify the reliability of the RegisterReportCallback function when devIndex is 0. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback001, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = 0; + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RegisterReportCallback_0400 + * @tc.name : testRegisterReportCallback002 + * @tc.desc : Verify the reliability of the RegisterReportCallback function when devIndex is 1-31. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback002, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) { + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->UnregisterReportCallback(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_NE(ret, INPUT_SUCCESS); + } + } +} + +/** + * @tc.number : SUB_Driver_Input_RegisterReportCallback_0500 + * @tc.name : testRegisterReportCallback003 + * @tc.desc : Verify the reliability of the RegisterReportCallback function when devIndex is 32. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback003, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = MAX_DEVICES; + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RegisterReportCallback_0600 + * @tc.name : testRegisterReportCallback004 + * @tc.desc : Verify the stability of the RegisterReportCallback function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback004, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + for (int32_t i = 0; i < 1000; i++) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->UnregisterReportCallback(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_UnregisterReportCallback_0200 + * @tc.name : testUnregisterReportCallback001 + * @tc.desc : Verify the reliability of the UnregisterReportCallback function when devIndex is 1. + */ +HWTEST_F(HdfInputHdiTestAdditional, testUnregisterReportCallback001, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + uint32_t devIndex = TOUCH_INDEX; + if (IsOnlineDev(devIndex)) { + ret = g_inputInterfaces->OpenInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->UnregisterReportCallback(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->CloseInputDevice(devIndex); + EXPECT_EQ(ret, INPUT_SUCCESS); + } else { + ret = g_inputInterfaces->UnregisterReportCallback(devIndex); + EXPECT_NE(ret, INPUT_SUCCESS); + } +} + +/** + * @tc.number : SUB_Driver_Input_RegisterHotPlugCallback_0100 + * @tc.name : testRegisterHotPlugCallback001 + * @tc.desc : Validation function RegisterHotPlugCallback results in success. + * when the hotPlugCallback parameter is g_callback + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterHotPlugCallback001, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + ret = g_inputInterfaces->RegisterHotPlugCallback(g_callback); + EXPECT_EQ(ret, INPUT_SUCCESS); + ret = g_inputInterfaces->UnregisterHotPlugCallback(); + EXPECT_EQ(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_RegisterHotPlugCallback_0200 + * @tc.name : testRegisterHotPlugCallback002 + * @tc.desc : Validation function RegisterHotPlugCallback results in success. + * when the hotPlugCallback parameter is nullptr + */ +HWTEST_F(HdfInputHdiTestAdditional, testRegisterHotPlugCallback002, Function | MediumTest | Level2) +{ + int32_t ret = INPUT_SUCCESS; + ret = g_inputInterfaces->RegisterHotPlugCallback(nullptr); + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.number : SUB_Driver_Input_UnregisterHotPlugCallback_0100 + * @tc.name : testUnregisterHotPlugCallback001 + * @tc.desc : Verify the reliability of UnregisterHotPlugCallback function and functional + */ +HWTEST_F(HdfInputHdiTestAdditional, testUnregisterHotPlugCallback001, Function | MediumTest | Level1) +{ + int32_t ret = INPUT_SUCCESS; + ret = g_inputInterfaces->UnregisterHotPlugCallback(); + EXPECT_EQ(ret, INPUT_SUCCESS); +} diff --git a/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp new file mode 100644 index 0000000000..bcdea7329e --- /dev/null +++ b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "input_callback_impl.h" +#include +#include + +namespace OHOS { +namespace HDI { +namespace Input { +namespace V1_0 { +InputCallbackImpl::InputCallbackImpl(const wptr &inputInterfaces_, + const wptr &reportCallback_) : inputInterfaces_(inputInterfaces_), + reportCallback_(reportCallback_) +{} + +int32_t InputCallbackImpl::EventPkgCallback(const std::vector &pkgs, uint32_t devIndex) +{ + if (pkgs.empty()) { + HDF_LOGE("%s: event packages are null\n", __func__); + return HDF_FAILURE; + } + for (uint32_t i = 0; i < pkgs.size(); i++) { + printf("%s: pkgs[%u] = 0x%x, 0x%x, %d\n", __func__, i, pkgs[i].type, pkgs[i].code, pkgs[i].value); + } + return HDF_SUCCESS; +} + +int32_t InputCallbackImpl::HotPlugCallback(const HotPlugEvent &event) +{ + if (event.devIndex == 0) { + return HDF_FAILURE; + } + + int32_t ret; + HDF_LOGI("%s: status = %d devId= %d type = %d", __func__, event.status, event.devIndex, event.devType); + + if (event.status == 0) { + ret = inputInterfaces_->OpenInputDevice(event.devIndex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: open device[%u] failed, ret %d", __func__, event.devIndex, ret); + return HDF_FAILURE; + } + + ret = inputInterfaces_->RegisterReportCallback(event.devIndex, reportCallback_.GetRefPtr()); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: register callback failed for device[%d], ret %d", __func__, event.devIndex, ret); + return HDF_FAILURE; + } + } else { + ret = inputInterfaces_->UnregisterReportCallback(event.devIndex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: unregister callback failed, ret %d", __func__, ret); + return HDF_FAILURE; + } + + ret = inputInterfaces_->CloseInputDevice(event.devIndex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: close device failed, ret %d", __func__, ret); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} +} // V1_0 +} // Input +} // HDI +} // OHOS diff --git a/input/test/unittest/hdi_passthrough_additional/input_callback_impl.h b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.h new file mode 100644 index 0000000000..536dd4bdb4 --- /dev/null +++ b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_INPUT_V1_0_INPUTCALLBACKIMPL_H +#define OHOS_HDI_INPUT_V1_0_INPUTCALLBACKIMPL_H + +#include "v1_0/iinput_callback.h" +#include "input_interfaces_impl.h" + +namespace OHOS { +namespace HDI { +namespace Input { +namespace V1_0 { +class InputCallbackImpl : public IInputCallback { +public: + InputCallbackImpl(const wptr &inputInterfaces, const wptr &otherCallback); + virtual ~InputCallbackImpl() = default; + int32_t EventPkgCallback(const std::vector &pkgs, uint32_t devIndex) override; + int32_t HotPlugCallback(const HotPlugEvent &event) override; +private: + wptr inputInterfaces_; + wptr reportCallback_; +}; +} // V1_0 +} // Input +} // HDI +} // OHOS + +#endif // OHOS_HDI_INPUT_V1_0_INPUTCALLBACKSERVICE_H \ No newline at end of file -- Gitee From c75fb4cdd31f5c7de21cf60f8bdf945f13eafc67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 6 Aug 2024 15:35:16 +0800 Subject: [PATCH 0071/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- codec/test/demo/adapter/BUILD.gn | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 codec/test/demo/adapter/BUILD.gn diff --git a/codec/test/demo/adapter/BUILD.gn b/codec/test/demo/adapter/BUILD.gn deleted file mode 100644 index e69de29bb2..0000000000 -- Gitee From 2196947d1ff6223615d064c3eadec7cc169ef7d1 Mon Sep 17 00:00:00 2001 From: hefeiyue Date: Tue, 6 Aug 2024 15:37:34 +0800 Subject: [PATCH 0072/1485] uninit vendor when close channel Signed-off-by: hefeiyue --- secure_element/vendor_adaptor/se_vendor_adaptions.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/secure_element/vendor_adaptor/se_vendor_adaptions.cpp b/secure_element/vendor_adaptor/se_vendor_adaptions.cpp index 6f1a38a9de..85026807b8 100644 --- a/secure_element/vendor_adaptor/se_vendor_adaptions.cpp +++ b/secure_element/vendor_adaptor/se_vendor_adaptions.cpp @@ -68,12 +68,6 @@ int32_t SeVendorAdaptions::init(const sptr& clientCallba } #ifdef SE_VENDOR_ADAPTION_USE_CA g_openedChannelCount = 0; - int ret = SecureElementCaProxy::GetInstance().VendorSecureElementCaInit(); - if (ret != SECURE_ELEMENT_CA_RET_OK) { - HDF_LOGE("VendorSecureElementCaInit failed ret %{public}u", ret); - status = SecureElementStatus::SE_GENERAL_ERROR; - return HDF_ERR_INVALID_PARAM; - } #endif g_callbackV1_0 = clientCallback; g_callbackV1_0->OnSeStateChanged(true); @@ -283,6 +277,7 @@ void SeVendorAdaptions::OnRemoteDied(const wptr &object) HDF_LOGI("OnRemoteDied, close channel [%{public}zu], status = %{public}d", i, status); } } + SecureElementCaProxy::GetInstance().VendorSecureElementCaUninit(); #endif std::lock_guard lock(g_mutex); g_callbackV1_0 = nullptr; -- Gitee From 5cf704d5dcc0a8e2ff25ab8d0a17d4cadeb034b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Tue, 6 Aug 2024 08:10:11 +0000 Subject: [PATCH 0073/1485] add uttest for controlTransferReadwithLengh MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- .../unittest/hal/include/usbd_transfer_test.h | 2 +- .../unittest/hal/src/usbd_transfer_test.cpp | 385 +++++++++++++++++- 2 files changed, 383 insertions(+), 4 deletions(-) diff --git a/usb/test/unittest/hal/include/usbd_transfer_test.h b/usb/test/unittest/hal/include/usbd_transfer_test.h index fe0f6df0b6..df1e4615ed 100644 --- a/usb/test/unittest/hal/include/usbd_transfer_test.h +++ b/usb/test/unittest/hal/include/usbd_transfer_test.h @@ -18,7 +18,7 @@ #include #include "UsbSubscriberTest.h" #include "v1_0/iusbd_subscriber.h" -#include "v1_0/usb_types.h" +#include "v1_1/usb_types.h" #include "v1_0/iusbd_bulk_callback.h" using OHOS::HDI::Usb::V1_0::UsbDev; diff --git a/usb/test/unittest/hal/src/usbd_transfer_test.cpp b/usb/test/unittest/hal/src/usbd_transfer_test.cpp index 07a42fdfc8..d96a87de43 100644 --- a/usb/test/unittest/hal/src/usbd_transfer_test.cpp +++ b/usb/test/unittest/hal/src/usbd_transfer_test.cpp @@ -24,8 +24,8 @@ #include "usb_ddk_interface.h" #include "securec.h" #include "usbd_type.h" -#include "v1_0/iusb_interface.h" -#include "v1_0/usb_types.h" +#include "v1_1/iusb_interface.h" +#include "v1_1/usb_types.h" const int SLEEP_TIME = 3; const uint8_t BUS_NUM_INVALID = 255; @@ -49,11 +49,12 @@ using namespace OHOS; using namespace OHOS::USB; using namespace std; using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_1; UsbDev UsbdTransferTest::dev_ = {0, 0}; sptr UsbdTransferTest::subscriber_ = nullptr; namespace { -sptr g_usbInterface = nullptr; +sptr g_usbInterface = nullptr; int32_t InitAshmemOne(sptr &asmptr, int32_t asmSize, uint8_t rflg) { @@ -953,6 +954,384 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite021, TestSize.Level1) ASSERT_NE(ret, 0); } +/** + * @tc.name: UsbdControlTransferReadwithLength001 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get configuration + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength001, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength001 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength002 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength002, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength002 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength003 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength003, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength003 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength004 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength004, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength004 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength005 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength005, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength005 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength006 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength006, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength006 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength007 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get interface + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength007, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t intercafeidex = 0; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, + USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength007 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength008 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength008, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + int32_t intercafeidex = 0; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, + USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength008 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength009 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength009, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + int32_t intercafeidex = 0; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, + USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength009 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength010 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get status(recipient device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength010, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength010 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength011 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength011, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength011 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength012 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength012, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength012 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength013 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get status(interface) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength013, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength013 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength014 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength014, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength014 ret%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength015 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength015, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength015 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength016 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength016, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength016 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength017 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength017, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength017 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength018 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint) + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength018, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, + 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength018 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength019 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: sync frame + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength019, TestSize.Level1) +{ + struct UsbDev dev = dev_; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, + 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength019 ret=%{public}d", ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength020 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength020, TestSize.Level1) +{ + struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, + 0, 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength020 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: UsbdControlTransferReadwithLength021 + * @tc.desc: Test functions to ControlTransferReadwithLength + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame + * @tc.type: FUNC + */ +HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength021, TestSize.Level1) +{ + struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, + 0, 0, TRANSFER_TIME_OUT}; + auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); + HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength021 ret=%{public}d", ret); + ASSERT_NE(ret, 0); +} + /** * @tc.name: UsbdBulkTransferRead001 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, -- Gitee From 27b5cf9cda2cd7e056bc7a6c868c1d15b581c89e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Tue, 6 Aug 2024 08:15:55 +0000 Subject: [PATCH 0074/1485] add domain MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/test/unittest/hal/src/usbd_transfer_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/test/unittest/hal/src/usbd_transfer_test.cpp b/usb/test/unittest/hal/src/usbd_transfer_test.cpp index d96a87de43..68747707c1 100644 --- a/usb/test/unittest/hal/src/usbd_transfer_test.cpp +++ b/usb/test/unittest/hal/src/usbd_transfer_test.cpp @@ -92,7 +92,7 @@ int32_t SwitchErrCode(int32_t ret) void UsbdTransferTest::SetUpTestCase(void) { - g_usbInterface = IUsbInterface::Get(); + g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); if (g_usbInterface == nullptr) { HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__); exit(0); -- Gitee From fed8a02c17fa0d2bf2ca364eb02516391bcc582c Mon Sep 17 00:00:00 2001 From: Joshua Date: Tue, 6 Aug 2024 16:30:24 +0800 Subject: [PATCH 0075/1485] support lowbitrate mode Signed-off-by: Joshua --- codec/interfaces/include/codec_omx_ext.h | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/codec/interfaces/include/codec_omx_ext.h b/codec/interfaces/include/codec_omx_ext.h index 72f18fb960..0b1a29fee9 100644 --- a/codec/interfaces/include/codec_omx_ext.h +++ b/codec/interfaces/include/codec_omx_ext.h @@ -16,6 +16,7 @@ #ifndef CODEC_OMX_EXT_H #define CODEC_OMX_EXT_H #include +#include #include #ifdef __cplusplus #if __cplusplus @@ -264,8 +265,24 @@ enum OmxIndexCodecExType { OMX_IndexParamQPStsart, /** OMX_BOOL */ OMX_IndexParamSkipFrame, + /** OMX_S32 */ + OMX_IndexParamEncOutRealBitrate, + /** CodecEncOutMadParam */ + OMX_IndexParamEncOutMad, + /** OMX_S32 */ + OMX_IndexParamEncOutIRatio, + /** OMX_S32 */ + OMX_IndexParamEncOutFrameQp, }; +/** + * @brief Enumerates the Other Control Rate Type. + */ +typedef enum OmxVideoControlRateVendorExtType { + /** constant bit rate mode with Rlambda */ + OMX_Video_ControlRateConstantWithRlambda = OMX_Video_ControlRateVendorStartUnused + 0x1, +} OmxVideoControlRateVendorExtType; + /** * @brief Enumerates the Other extended codec indexes. */ @@ -380,6 +397,12 @@ struct CodecParamOverlayBuffer { void* bufferHandle; }; +struct CodecEncOutMadParam { + int32_t frameMadi; + int32_t frameMadp; + int32_t sumMadi; +}; + #ifdef __cplusplus #if __cplusplus } -- Gitee From 344d43d1d8fa014e310180c8a4aa2f2a32e6edc8 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Tue, 6 Aug 2024 17:05:47 +0800 Subject: [PATCH 0076/1485] codec HDI clean code Signed-off-by: suxiaosu007 --- codec/hal/src/codec_callback_type_stub.c | 1 + 1 file changed, 1 insertion(+) diff --git a/codec/hal/src/codec_callback_type_stub.c b/codec/hal/src/codec_callback_type_stub.c index 5f90ef5f18..95c0fc2df9 100644 --- a/codec/hal/src/codec_callback_type_stub.c +++ b/codec/hal/src/codec_callback_type_stub.c @@ -267,6 +267,7 @@ struct CodecCallbackType *CodecCallbackTypeStubGetInstance(void) if (!HdfRemoteServiceSetInterfaceDesc(stub->service.remote, "ohos.hdi.codec_service")) { CODEC_LOGE("failed to init interface desc"); + OsalMemFree(stub); return NULL; } -- Gitee From 5c6af5c7799ad8de5c874f8b0722836efffbb391 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Tue, 6 Aug 2024 12:25:02 +0000 Subject: [PATCH 0077/1485] fix alarm MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/test/unittest/hal/src/usbd_transfer_test.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/usb/test/unittest/hal/src/usbd_transfer_test.cpp b/usb/test/unittest/hal/src/usbd_transfer_test.cpp index 68747707c1..12311313ba 100644 --- a/usb/test/unittest/hal/src/usbd_transfer_test.cpp +++ b/usb/test/unittest/hal/src/usbd_transfer_test.cpp @@ -1317,7 +1317,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength020, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength021 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame * @tc.type: FUNC */ @@ -1325,8 +1326,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength021, TestSize.Level1 { struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID}; std::vector bufferData(MAX_BUFFER_LENGTH); - struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, - 0, 0, TRANSFER_TIME_OUT}; + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, + USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT}; auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength021 ret=%{public}d", ret); ASSERT_NE(ret, 0); -- Gitee From 3a5c9c059e5c584e14d146050b05d5ce8923cb77 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Tue, 6 Aug 2024 21:40:03 +0800 Subject: [PATCH 0078/1485] =?UTF-8?q?OsalMemFree=E5=90=8E=E7=BD=AE?= =?UTF-8?q?=E7=A9=BA=E9=98=B2=E6=AD=A2double=20free?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hechaofan --- usb/gadget/function/ecm/cdcecm.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/usb/gadget/function/ecm/cdcecm.c b/usb/gadget/function/ecm/cdcecm.c index 07992cf1e5..170457c4ba 100644 --- a/usb/gadget/function/ecm/cdcecm.c +++ b/usb/gadget/function/ecm/cdcecm.c @@ -872,12 +872,13 @@ static int32_t UsbEcmAlloc(struct UsbEcmDevice *ecm) static void UsbEcmFree(struct UsbEcmDevice *ecm) { - if (ecm->port != NULL) { + if (ecm != NULL && ecm->port != NULL) { OsalMutexDestroy(&ecm->port->lock); OsalMutexDestroy(&ecm->port->lockRW); OsalMutexDestroy(&ecm->port->lockReadFifo); OsalMutexDestroy(&ecm->port->lockWriteFifo); OsalMemFree(ecm->port); + ecm->port = NULL; } } @@ -1027,6 +1028,7 @@ static void EcmDriverRelease(struct HdfDeviceObject *device) UsbEcmFree(ecm); (void)OsalMutexDestroy(&ecm->lock); OsalMemFree(ecm); + ecm = NULL; } struct HdfDriverEntry g_ecmDriverEntry = { -- Gitee From a395ee44f651346115be0293fe839c0634a382da Mon Sep 17 00:00:00 2001 From: pingliao Date: Tue, 6 Aug 2024 21:50:47 +0800 Subject: [PATCH 0079/1485] fix: unlock Signed-off-by: pingliao --- usb/ddk/host/src/usb_interface_pool.c | 1 + usb/hdi_service/src/usb_impl.cpp | 2 ++ 2 files changed, 3 insertions(+) diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index 298417d475..da94a6b758 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1365,6 +1365,7 @@ int32_t UsbCloseCtlProcess(const UsbInterfaceHandle *interfaceHandle) ret = UsbIoRecvProcessStop(interfacePool); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s:%{public}d UsbIoStop failed, ret = %{public}d", __func__, __LINE__, ret); + OsalMutexUnlock(&interfacePool->interfaceLock); return ret; } } diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 2db8b09a66..affb696daf 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -475,6 +475,7 @@ int32_t UsbImpl::UsbdBulkReadSyncBase( ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: UsbFillRequest failed, ret=%{public}d ", __func__, ret); + OsalMutexUnlock(&requestSync->lock); return HDF_FAILURE; } requestSync->params.timeout = static_cast(timeout); @@ -488,6 +489,7 @@ int32_t UsbImpl::UsbdBulkReadSyncBase( requestSync->request->compInfo.actualLength); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: memcpy_s failed, ret = %{public}d", __func__, ret); + OsalMutexUnlock(&requestSync->lock); return HDF_FAILURE; } tcur += requestSync->request->compInfo.actualLength; -- Gitee From fc7cf37f268141bf530bf32746347b5b68fc067e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Wed, 7 Aug 2024 01:28:33 +0000 Subject: [PATCH 0080/1485] add fuzztest and benchmarktest MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/test/benchmarktest/BUILD.gn | 2 +- .../usb_benchmark_transfer_test.cpp | 37 ++++++++-- .../usbbulktransferread_fuzzer.cpp | 2 +- .../usbbulktransferwrite_fuzzer.cpp | 2 +- .../usbcontroltransferread_fuzzer.cpp | 3 +- .../BUILD.gn | 55 +++++++++++++++ .../corpus/init | 14 ++++ .../project.xml | 25 +++++++ ...sbcontroltransferreadwithlength_fuzzer.cpp | 70 +++++++++++++++++++ .../usbcontroltransferreadwithlength_fuzzer.h | 21 ++++++ .../usbcontroltransferwrite_fuzzer.cpp | 3 +- .../usbgetconfigdescriptor_fuzzer.cpp | 3 +- .../usbgetstringdescriptor_fuzzer.cpp | 3 +- .../usbinterrupttransferread_fuzzer.cpp | 2 +- .../usbinterrupttransferwrite_fuzzer.cpp | 2 +- .../usbisotransferread_fuzzer.cpp | 2 +- .../usbisotransferwrite_fuzzer.cpp | 2 +- .../usbregbulkcallback_fuzzer.cpp | 3 +- .../usbrequestqueue_fuzzer.cpp | 5 +- .../usbrequestwait_fuzzer.cpp | 3 +- 20 files changed, 240 insertions(+), 19 deletions(-) create mode 100644 usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn create mode 100644 usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/corpus/init create mode 100644 usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/project.xml create mode 100644 usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.cpp create mode 100644 usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.h diff --git a/usb/test/benchmarktest/BUILD.gn b/usb/test/benchmarktest/BUILD.gn index e7116c89d8..b8eee28e88 100644 --- a/usb/test/benchmarktest/BUILD.gn +++ b/usb/test/benchmarktest/BUILD.gn @@ -131,7 +131,7 @@ ohos_benchmarktest("hdf_usb_benchmark_transfer_test") { if (is_standard_system) { external_deps = [ - "drivers_interface_usb:libusb_proxy_1.0", + "drivers_interface_usb:libusb_proxy_1.1", "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", diff --git a/usb/test/benchmarktest/usb_benchmark_transfer_test.cpp b/usb/test/benchmarktest/usb_benchmark_transfer_test.cpp index f6db228f04..a0813d6164 100644 --- a/usb/test/benchmarktest/usb_benchmark_transfer_test.cpp +++ b/usb/test/benchmarktest/usb_benchmark_transfer_test.cpp @@ -23,17 +23,18 @@ #include "usbd_port.h" #include "usbd_function.h" #include "UsbSubscriberTest.h" -#include "v1_0/iusb_interface.h" -#include "v1_0/usb_types.h" +#include "v1_1/iusb_interface.h" +#include "v1_1/usb_types.h" using namespace benchmark::internal; using namespace OHOS; using namespace std; using namespace OHOS::USB; using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_1; namespace { -sptr g_usbInterface = nullptr; +sptr g_usbInterface = nullptr; struct UsbDev g_dev = {0, 0}; const int SLEEP_TIME = 3; const uint8_t INTERFACEID_OK = 1; @@ -107,7 +108,7 @@ int32_t SwitchErrCode(int32_t ret) void HdfUsbdBenchmarkTransferTest::SetUp(const ::benchmark::State& state) { - g_usbInterface = IUsbInterface::Get(); + g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); ASSERT_NE(g_usbInterface, nullptr); auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST); sleep(SLEEP_TIME); @@ -194,6 +195,34 @@ BENCHMARK_F(HdfUsbdBenchmarkTransferTest, ControlTransferWrite)(benchmark::State BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, ControlTransferWrite)-> Iterations(ITERATION_WRITE_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly(); +/** + * @tc.name: ControlTransferReadwithLengh + * @tc.desc: Benchmark test + * @tc.desc: Test functions to ControlTransferReadwithLengh(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * std::vector &data); + * @tc.desc: Positive test: parameters correctly, standard request: get configuration + * @tc.type: FUNC + */ +BENCHMARK_F(HdfUsbdBenchmarkTransferTest, ControlTransferReadwithLengh)(benchmark::State& state) +{ + ASSERT_TRUE(g_usbInterface != nullptr); + int32_t ret; + sptr subscriber = new UsbSubscriberTest(); + ASSERT_TRUE(subscriber != nullptr); + InitPara(subscriber); + std::vector bufferData(MAX_BUFFER_LENGTH); + struct UsbCtrlTransferParams ctrlparmas = { + USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, 0, TRANSFER_TIME_OUT}; + for (auto _ : state) { + ret = g_usbInterface->ControlTransferReadwithLength(g_dev, ctrlparmas, bufferData); + } + EXPECT_EQ(0, ret); + ReleasePara(subscriber); +} + +BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, ControlTransferReadwithLengh)-> + Iterations(ITERATION_READ_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly(); + /** * @tc.name: BulkTransferRead * @tc.desc: Benchmark test diff --git a/usb/test/fuzztest/usbbulktransferread_fuzzer/usbbulktransferread_fuzzer.cpp b/usb/test/fuzztest/usbbulktransferread_fuzzer/usbbulktransferread_fuzzer.cpp index bff101d5aa..537b485eac 100644 --- a/usb/test/fuzztest/usbbulktransferread_fuzzer/usbbulktransferread_fuzzer.cpp +++ b/usb/test/fuzztest/usbbulktransferread_fuzzer/usbbulktransferread_fuzzer.cpp @@ -45,7 +45,7 @@ bool UsbBulkTransferReadFuzzTest(const uint8_t *data, size_t size) } int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->BulkTransferRead( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET_BYTE)); + dev, pipe, timeout, reinterpret_cast &>std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: bulk transfer read succeed", __func__); } diff --git a/usb/test/fuzztest/usbbulktransferwrite_fuzzer/usbbulktransferwrite_fuzzer.cpp b/usb/test/fuzztest/usbbulktransferwrite_fuzzer/usbbulktransferwrite_fuzzer.cpp index 7ff0f162fd..248ed49d24 100644 --- a/usb/test/fuzztest/usbbulktransferwrite_fuzzer/usbbulktransferwrite_fuzzer.cpp +++ b/usb/test/fuzztest/usbbulktransferwrite_fuzzer/usbbulktransferwrite_fuzzer.cpp @@ -45,7 +45,7 @@ bool UsbBulkTransferWriteFuzzTest(const uint8_t *data, size_t size) } int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->BulkTransferWrite( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET_BYTE)); + dev, pipe, timeout, reinterpret_cast &>std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: bulk transfer Write succeed", __func__); } diff --git a/usb/test/fuzztest/usbcontroltransferread_fuzzer/usbcontroltransferread_fuzzer.cpp b/usb/test/fuzztest/usbcontroltransferread_fuzzer/usbcontroltransferread_fuzzer.cpp index c118efa284..e2dfed5df2 100644 --- a/usb/test/fuzztest/usbcontroltransferread_fuzzer/usbcontroltransferread_fuzzer.cpp +++ b/usb/test/fuzztest/usbcontroltransferread_fuzzer/usbcontroltransferread_fuzzer.cpp @@ -43,7 +43,8 @@ bool UsbControlTransferReadFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->ControlTransferRead(dev, ctrl, reinterpret_cast &>(data + OFFSET)); + ret = usbInterface->ControlTransferRead( + dev, ctrl, reinterpret_cast &>(std::move(data + OFFSET))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: control transfer read succeed", __func__); } diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn new file mode 100644 index 0000000000..c034b95dfb --- /dev/null +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbControlTransferReadwithLengthFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbcontroltransferreadwithlength_fuzzer" + + include_dirs = [ + "./.../usbcontroltransferreadwithlength_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + ".../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbcontroltransferreadwithlength_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbControlTransferReadwithLengthFuzzTest" ] +} diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/corpus/init b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/corpus/init new file mode 100644 index 0000000000..7e96755ef6 --- /dev/null +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/project.xml b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/project.xml new file mode 100644 index 0000000000..823e52f374 --- /dev/null +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + \ No newline at end of file diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.cpp b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.cpp new file mode 100644 index 0000000000..1c8516b901 --- /dev/null +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "usbcontroltransferreadwithlength_fuzzer.h" +#include "UsbSubscriberTest.h" +#include "hdf_log.h" +#include "securec.h" +#include "usbcommonfunction_fuzzer.h" +#include "v1_1/iusb_interface.h" + +using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_1; + +namespace OHOS { +constexpr size_t THRESHOLD = 10; +constexpr int32_t OFFSET = 4; +namespace USB { +bool UsbControlTransferReadwithLengthFuzzTest(const uint8_t *data, size_t size) +{ + (void)size; + UsbDev dev; + sptr usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); + int32_t ret = UsbFuzzTestHostModeInit(dev, usbInterface); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: UsbFuzzTestHostModeInit failed", __func__); + return false; + } + + UsbCtrlTransferParams ctrl; + if (memcpy_s((void *)&ctrl, sizeof(ctrl), data, sizeof(ctrl)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s failed", __func__); + return false; + } + + ret = usbInterface->ControlTransferReadwithLength( + dev, ctrl, reinterpret_cast &>(std::move(data + OFFSET))); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%{public}s: control transfer read succeed", __func__); + } + + ret = usbInterface->CloseDevice(dev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: close device failed", __func__); + return false; + } + return true; +} +} // namespace USB +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + if (size < OHOS::THRESHOLD) { + return 0; + } + OHOS::USB::UsbControlTransferReadwithLengthFuzzTest(data, size); + return 0; +} \ No newline at end of file diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.h b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.h new file mode 100644 index 0000000000..8089e5f732 --- /dev/null +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/usbcontroltransferreadwithlength_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USBCONTROLTRANSFERREADWITHLENGTH_FUZZER_H +#define USBCONTROLTRANSFERREADWITHLENGTH_FUZZER_H + +#define FUZZ_PROJECT_NAME "usbcontroltransferreadwithlength_fuzzer" + +#endif \ No newline at end of file diff --git a/usb/test/fuzztest/usbcontroltransferwrite_fuzzer/usbcontroltransferwrite_fuzzer.cpp b/usb/test/fuzztest/usbcontroltransferwrite_fuzzer/usbcontroltransferwrite_fuzzer.cpp index 40678536d4..1fea5e237b 100644 --- a/usb/test/fuzztest/usbcontroltransferwrite_fuzzer/usbcontroltransferwrite_fuzzer.cpp +++ b/usb/test/fuzztest/usbcontroltransferwrite_fuzzer/usbcontroltransferwrite_fuzzer.cpp @@ -43,7 +43,8 @@ bool UsbControlTransferWriteFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->ControlTransferWrite(dev, ctrl, reinterpret_cast &>(data + OFFSET)); + ret = usbInterface->ControlTransferWrite( + dev, ctrl, reinterpret_cast &>(std::move(data + OFFSET))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: control transfer write succeed", __func__); } diff --git a/usb/test/fuzztest/usbgetconfigdescriptor_fuzzer/usbgetconfigdescriptor_fuzzer.cpp b/usb/test/fuzztest/usbgetconfigdescriptor_fuzzer/usbgetconfigdescriptor_fuzzer.cpp index 7399e9c9a9..ddf2875393 100644 --- a/usb/test/fuzztest/usbgetconfigdescriptor_fuzzer/usbgetconfigdescriptor_fuzzer.cpp +++ b/usb/test/fuzztest/usbgetconfigdescriptor_fuzzer/usbgetconfigdescriptor_fuzzer.cpp @@ -36,7 +36,8 @@ bool UsbGetConfigDescriptorFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->GetConfigDescriptor(dev, *data, reinterpret_cast &>(data + OFFSET)); + ret = usbInterface->GetConfigDescriptor( + dev, *data, reinterpret_cast &>(std::move(data + OFFSET))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: get config descriptor succeed", __func__); } diff --git a/usb/test/fuzztest/usbgetstringdescriptor_fuzzer/usbgetstringdescriptor_fuzzer.cpp b/usb/test/fuzztest/usbgetstringdescriptor_fuzzer/usbgetstringdescriptor_fuzzer.cpp index 0ab1d8913b..b156c79db9 100644 --- a/usb/test/fuzztest/usbgetstringdescriptor_fuzzer/usbgetstringdescriptor_fuzzer.cpp +++ b/usb/test/fuzztest/usbgetstringdescriptor_fuzzer/usbgetstringdescriptor_fuzzer.cpp @@ -36,7 +36,8 @@ bool UsbGetStringDescriptorFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->GetStringDescriptor(dev, *data, reinterpret_cast &>(data + OFFSET)); + ret = usbInterface->GetStringDescriptor( + dev, *data, reinterpret_cast &>(std::move(data + OFFSET))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: get string descriptor succeed", __func__); } diff --git a/usb/test/fuzztest/usbinterrupttransferread_fuzzer/usbinterrupttransferread_fuzzer.cpp b/usb/test/fuzztest/usbinterrupttransferread_fuzzer/usbinterrupttransferread_fuzzer.cpp index a6c1e1a2d7..15bccfaa2a 100644 --- a/usb/test/fuzztest/usbinterrupttransferread_fuzzer/usbinterrupttransferread_fuzzer.cpp +++ b/usb/test/fuzztest/usbinterrupttransferread_fuzzer/usbinterrupttransferread_fuzzer.cpp @@ -46,7 +46,7 @@ bool UsbInterruptTransferReadFuzzTest(const uint8_t *data, size_t size) int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->InterruptTransferRead( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET_BYTE)); + dev, pipe, timeout, reinterpret_cast &>(std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: interrupt transfer read succeed", __func__); } diff --git a/usb/test/fuzztest/usbinterrupttransferwrite_fuzzer/usbinterrupttransferwrite_fuzzer.cpp b/usb/test/fuzztest/usbinterrupttransferwrite_fuzzer/usbinterrupttransferwrite_fuzzer.cpp index 35ca48f94b..2495ff057c 100644 --- a/usb/test/fuzztest/usbinterrupttransferwrite_fuzzer/usbinterrupttransferwrite_fuzzer.cpp +++ b/usb/test/fuzztest/usbinterrupttransferwrite_fuzzer/usbinterrupttransferwrite_fuzzer.cpp @@ -46,7 +46,7 @@ bool UsbInterruptTransferWriteFuzzTest(const uint8_t *data, size_t size) int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->InterruptTransferWrite( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET)); + dev, pipe, timeout, reinterpret_cast &>(std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: interrupt transfer write succeed", __func__); } diff --git a/usb/test/fuzztest/usbisotransferread_fuzzer/usbisotransferread_fuzzer.cpp b/usb/test/fuzztest/usbisotransferread_fuzzer/usbisotransferread_fuzzer.cpp index fb53433805..bf53aeb3c2 100644 --- a/usb/test/fuzztest/usbisotransferread_fuzzer/usbisotransferread_fuzzer.cpp +++ b/usb/test/fuzztest/usbisotransferread_fuzzer/usbisotransferread_fuzzer.cpp @@ -46,7 +46,7 @@ bool UsbIsoTransferReadFuzzTest(const uint8_t *data, size_t size) int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->IsoTransferRead( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET_BYTE)); + dev, pipe, timeout, reinterpret_cast &>(std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: iso transfer read succeed", __func__); } diff --git a/usb/test/fuzztest/usbisotransferwrite_fuzzer/usbisotransferwrite_fuzzer.cpp b/usb/test/fuzztest/usbisotransferwrite_fuzzer/usbisotransferwrite_fuzzer.cpp index 1af14d7ee0..d42a936928 100644 --- a/usb/test/fuzztest/usbisotransferwrite_fuzzer/usbisotransferwrite_fuzzer.cpp +++ b/usb/test/fuzztest/usbisotransferwrite_fuzzer/usbisotransferwrite_fuzzer.cpp @@ -46,7 +46,7 @@ bool UsbIsoTransferWriteFuzzTest(const uint8_t *data, size_t size) int32_t timeout = *(reinterpret_cast(*(data + OFFSET))); ret = usbInterface->IsoTransferWrite( - dev, pipe, timeout, reinterpret_cast &>(data + OFFSET_BYTE)); + dev, pipe, timeout, reinterpret_cast &>(std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: iso transfer write succeed", __func__); } diff --git a/usb/test/fuzztest/usbregbulkcallback_fuzzer/usbregbulkcallback_fuzzer.cpp b/usb/test/fuzztest/usbregbulkcallback_fuzzer/usbregbulkcallback_fuzzer.cpp index 2985bf797d..e45dd261fa 100644 --- a/usb/test/fuzztest/usbregbulkcallback_fuzzer/usbregbulkcallback_fuzzer.cpp +++ b/usb/test/fuzztest/usbregbulkcallback_fuzzer/usbregbulkcallback_fuzzer.cpp @@ -44,7 +44,8 @@ bool UsbRegBulkCallbackFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->RegBulkCallback(dev, pipe, reinterpret_cast &>(data + OFFSET)); + ret = usbInterface->RegBulkCallback( + dev, pipe, reinterpret_cast &>(std::move(data + OFFSET))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: reg bulk callback succeed", __func__); } diff --git a/usb/test/fuzztest/usbrequestqueue_fuzzer/usbrequestqueue_fuzzer.cpp b/usb/test/fuzztest/usbrequestqueue_fuzzer/usbrequestqueue_fuzzer.cpp index f987c1f8a1..247960b2f6 100644 --- a/usb/test/fuzztest/usbrequestqueue_fuzzer/usbrequestqueue_fuzzer.cpp +++ b/usb/test/fuzztest/usbrequestqueue_fuzzer/usbrequestqueue_fuzzer.cpp @@ -44,8 +44,9 @@ bool UsbRequestQueueFuzzTest(const uint8_t *data, size_t size) return false; } - ret = usbInterface->RequestQueue(dev, pipe, reinterpret_cast &>(data + OFFSET), - reinterpret_cast &>(data + OFFSET_BYTE)); + ret = usbInterface->RequestQueue( + dev, pipe, reinterpret_cast &>(std::move(data + OFFSET)), + reinterpret_cast &>(std::move(data + OFFSET_BYTE))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: reg bulk callback succeed", __func__); } diff --git a/usb/test/fuzztest/usbrequestwait_fuzzer/usbrequestwait_fuzzer.cpp b/usb/test/fuzztest/usbrequestwait_fuzzer/usbrequestwait_fuzzer.cpp index ecd4ccbe74..784e5951f3 100644 --- a/usb/test/fuzztest/usbrequestwait_fuzzer/usbrequestwait_fuzzer.cpp +++ b/usb/test/fuzztest/usbrequestwait_fuzzer/usbrequestwait_fuzzer.cpp @@ -38,7 +38,8 @@ bool UsbRequestWaitFuzzTest(const uint8_t *data, size_t size) } ret = usbInterface->RequestWait(dev, reinterpret_cast &>(data), - reinterpret_cast &>(data + OFFSET), *(reinterpret_cast(*(data + OFFSET_BYTE)))); + reinterpret_cast &>(std::move(data + OFFSET)), + *(reinterpret_cast(*(data + OFFSET_BYTE)))); if (ret == HDF_SUCCESS) { HDF_LOGI("%{public}s: request wait succeed", __func__); } -- Gitee From 953167cbb7f4a248377332a8f20e63ef2b0eb060 Mon Sep 17 00:00:00 2001 From: xupeng Date: Wed, 7 Aug 2024 10:44:14 +0800 Subject: [PATCH 0081/1485] EFFECT_SPATIAL_DEVICE_TYPE Signed-off-by: xupeng --- audio/interfaces/effect/v1_0/effect_types_vdi.h | 1 + 1 file changed, 1 insertion(+) diff --git a/audio/interfaces/effect/v1_0/effect_types_vdi.h b/audio/interfaces/effect/v1_0/effect_types_vdi.h index 3985577ba7..bb090c89cb 100644 --- a/audio/interfaces/effect/v1_0/effect_types_vdi.h +++ b/audio/interfaces/effect/v1_0/effect_types_vdi.h @@ -74,6 +74,7 @@ enum AudioEffectHDICommandVdi { EFFECT_ROOM_MODE = 3, EFFECT_BLUETOOTH_MODE = 4, EFFECT_DESTROY = 5, + EFFECT_SPATIAL_DEVICE_TYPE = 6, }; #ifdef __cplusplus -- Gitee From 80bb7a903d5021a76729cbf499eb5159ea0661ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Wed, 7 Aug 2024 02:57:33 +0000 Subject: [PATCH 0082/1485] fix more than 120 characters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- .../BUILD.gn | 108 +++++++++--------- .../unittest/hal/src/usbd_transfer_test.cpp | 68 +++++++---- 2 files changed, 98 insertions(+), 78 deletions(-) diff --git a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn index c034b95dfb..dfc88fd4e0 100644 --- a/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn +++ b/usb/test/fuzztest/usbcontroltransferreadwithlength_fuzzer/BUILD.gn @@ -1,55 +1,55 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and # limitations under the License. - -import("//build/config/features.gni") -import("//build/ohos.gni") -import("//build/test.gni") -import("./../fuzztest.gni") -module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" - -ohos_fuzztest("UsbControlTransferReadwithLengthFuzzTest") { - module_out_path = module_output_path - - fuzz_config_file = "./../usbcontroltransferreadwithlength_fuzzer" - - include_dirs = [ - "./.../usbcontroltransferreadwithlength_fuzzer", - "./../../UsbSubscriberTest", - "./../usbcommonfunction_fuzzer", - ".../../../../../base/usb/usb_manager/utils/native/include", - "../../../hdi_service/include", - ] - - deps = [ "./../../../ddk:libusb_core" ] - - external_deps = usb_test_fuzzer_external_deps - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", - "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", - "usbcontroltransferreadwithlength_fuzzer.cpp", - ] -} - -group("fuzztest") { - testonly = true - deps = [] - deps += [ ":UsbControlTransferReadwithLengthFuzzTest" ] -} + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbControlTransferReadwithLengthFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbcontroltransferreadwithlength_fuzzer" + + include_dirs = [ + "./.../usbcontroltransferreadwithlength_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + ".../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbcontroltransferreadwithlength_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbControlTransferReadwithLengthFuzzTest" ] +} diff --git a/usb/test/unittest/hal/src/usbd_transfer_test.cpp b/usb/test/unittest/hal/src/usbd_transfer_test.cpp index 12311313ba..85fc9e97a9 100644 --- a/usb/test/unittest/hal/src/usbd_transfer_test.cpp +++ b/usb/test/unittest/hal/src/usbd_transfer_test.cpp @@ -957,7 +957,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferWrite021, TestSize.Level1) /** * @tc.name: UsbdControlTransferReadwithLength001 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get configuration * @tc.type: FUNC */ @@ -975,7 +976,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength001, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength002 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration * @tc.type: FUNC */ @@ -993,7 +995,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength002, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength003 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration * @tc.type: FUNC */ @@ -1011,7 +1014,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength003, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength004 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device) * @tc.type: FUNC */ @@ -1029,7 +1033,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength004, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength005 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device) * @tc.type: FUNC */ @@ -1047,7 +1052,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength005, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength006 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device) * @tc.type: FUNC */ @@ -1065,7 +1071,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength006, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength007 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get interface * @tc.type: FUNC */ @@ -1084,7 +1091,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength007, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength008 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface * @tc.type: FUNC */ @@ -1103,7 +1111,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength008, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength009 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface * @tc.type: FUNC */ @@ -1122,7 +1131,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength009, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength010 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get status(recipient device) * @tc.type: FUNC */ @@ -1139,7 +1149,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength010, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength011 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device) * @tc.type: FUNC */ @@ -1156,7 +1167,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength011, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength012 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device) * @tc.type: FUNC */ @@ -1173,7 +1185,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength012, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength013 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get status(interface) * @tc.type: FUNC */ @@ -1191,7 +1204,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength013, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength014 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface) * @tc.type: FUNC */ @@ -1209,7 +1223,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength014, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength015 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface) * @tc.type: FUNC */ @@ -1227,7 +1242,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength015, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength016 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint) * @tc.type: FUNC */ @@ -1245,7 +1261,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength016, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength017 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint) * @tc.type: FUNC */ @@ -1263,7 +1280,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength017, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength018 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint) * @tc.type: FUNC */ @@ -1281,7 +1299,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength018, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength019 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Positive test: parameters correctly, standard request: sync frame * @tc.type: FUNC */ @@ -1289,8 +1308,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength019, TestSize.Level1 { struct UsbDev dev = dev_; std::vector bufferData(MAX_BUFFER_LENGTH); - struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, - 0, 0, 0, TRANSFER_TIME_OUT}; + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, + USB_DDK_REQ_SYNCH_FRAME, 0, 0, 0, TRANSFER_TIME_OUT}; auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength019 ret=%{public}d", ret); ASSERT_EQ(0, ret); @@ -1299,7 +1318,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength019, TestSize.Level1 /** * @tc.name: UsbdControlTransferReadwithLength020 * @tc.desc: Test functions to ControlTransferReadwithLength - * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, std::vector &data); + * @tc.desc: int32_t ControlTransferReadwithLength(const UsbDev &dev, UsbCtrlTransferParams &ctrl, + * @tc.desc: std::vector &data); * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame * @tc.type: FUNC */ @@ -1307,8 +1327,8 @@ HWTEST_F(UsbdTransferTest, UsbdControlTransferReadwithLength020, TestSize.Level1 { struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr}; std::vector bufferData(MAX_BUFFER_LENGTH); - struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, - 0, 0, 0, TRANSFER_TIME_OUT}; + struct UsbCtrlTransferParams ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, + USB_DDK_REQ_SYNCH_FRAME, 0, 0, 0, TRANSFER_TIME_OUT}; auto ret = g_usbInterface->ControlTransferReadwithLength(dev, ctrlparmas, bufferData); HDF_LOGI("UsbdTransferTest::UsbdControlTransferReadwithLength020 ret=%{public}d", ret); ASSERT_NE(ret, 0); -- Gitee From cbea29ad6233a4ba134ba0f3411656ff8ec2a5ad Mon Sep 17 00:00:00 2001 From: l60050612 Date: Wed, 7 Aug 2024 11:12:34 +0800 Subject: [PATCH 0083/1485] =?UTF-8?q?audio=E6=A8=A1=E5=9D=97=E6=96=B0?= =?UTF-8?q?=E5=A2=9Etrace=E7=BB=B4=E6=B5=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c | 5 ++++- audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c index a2202c37c0..4aeee8994e 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c @@ -132,8 +132,11 @@ int32_t AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *fram struct IAudioCaptureVdi *vdiCapture = captureInfo->vdiCapture; CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetCapturePosition, HDF_ERR_INVALID_PARAM); - + + HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); int32_t ret = vdiCapture->GetCapturePosition(vdiCapture, frames, (struct AudioTimeStampVdi *)time); + HdfAudioFinishTrace(); + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio capture get position fail, ret=%{public}d", ret); return ret; diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 40b817b1ed..356337c452 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -112,8 +112,11 @@ int32_t AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM); - + + HdfAudioStartTrace("Hdi:AudioGetRenderPositionVdi", 0); int32_t ret = vdiRender->GetRenderPosition(vdiRender, frames, (struct AudioTimeStampVdi *)time); + HdfAudioFinishTrace(); + if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio render, get position fail, ret=%{public}d", ret); return ret; -- Gitee From a9517d50cc926b8ed036674fa8340371607d1f67 Mon Sep 17 00:00:00 2001 From: l60050612 Date: Wed, 7 Aug 2024 03:24:32 +0000 Subject: [PATCH 0084/1485] update audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c. Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c index 4aeee8994e..4471e64530 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c @@ -133,9 +133,9 @@ int32_t AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *fram CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetCapturePosition, HDF_ERR_INVALID_PARAM); - HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); +HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); int32_t ret = vdiCapture->GetCapturePosition(vdiCapture, frames, (struct AudioTimeStampVdi *)time); - HdfAudioFinishTrace(); +HdfAudioFinishTrace(); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio capture get position fail, ret=%{public}d", ret); -- Gitee From 68b88382d6bc3034061db0133bbf5b7d0aac5ed3 Mon Sep 17 00:00:00 2001 From: l60050612 Date: Wed, 7 Aug 2024 03:25:49 +0000 Subject: [PATCH 0085/1485] update audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c. Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c index 4471e64530..4df688ac1a 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c @@ -133,9 +133,9 @@ int32_t AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *fram CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->GetCapturePosition, HDF_ERR_INVALID_PARAM); -HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); + HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); int32_t ret = vdiCapture->GetCapturePosition(vdiCapture, frames, (struct AudioTimeStampVdi *)time); -HdfAudioFinishTrace(); + HdfAudioFinishTrace(); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio capture get position fail, ret=%{public}d", ret); -- Gitee From b3ea455bdb1b9c20330d31d40e6aae184090f84a Mon Sep 17 00:00:00 2001 From: l60050612 Date: Wed, 7 Aug 2024 03:26:58 +0000 Subject: [PATCH 0086/1485] update audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c. Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c | 1 - 1 file changed, 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c index 4df688ac1a..43758858eb 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c @@ -136,7 +136,6 @@ int32_t AudioGetCapturePositionVdi(struct IAudioCapture *capture, uint64_t *fram HdfAudioStartTrace("Hdi:AudioGetCapturePositionVdi", 0); int32_t ret = vdiCapture->GetCapturePosition(vdiCapture, frames, (struct AudioTimeStampVdi *)time); HdfAudioFinishTrace(); - if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio capture get position fail, ret=%{public}d", ret); return ret; -- Gitee From 29c719429c089cd9727e58f9fa3820af7493b05b Mon Sep 17 00:00:00 2001 From: l60050612 Date: Wed, 7 Aug 2024 03:27:45 +0000 Subject: [PATCH 0087/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 356337c452..bb11c6dec9 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -113,10 +113,9 @@ int32_t AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM); - HdfAudioStartTrace("Hdi:AudioGetRenderPositionVdi", 0); + HdfAudioStartTrace("Hdi:AudioGetRenderPositionVdi", 0); int32_t ret = vdiRender->GetRenderPosition(vdiRender, frames, (struct AudioTimeStampVdi *)time); - HdfAudioFinishTrace(); - + HdfAudioFinishTrace(); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio render, get position fail, ret=%{public}d", ret); return ret; -- Gitee From 53b6bf7efe2888bb3bfccc45d0430a30adf77a65 Mon Sep 17 00:00:00 2001 From: chen0088 Date: Tue, 6 Aug 2024 19:12:43 +0800 Subject: [PATCH 0088/1485] modify Signed-off-by: chen0088 --- .../src/dcamera_device/dmetadata_processor.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp b/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp index 007d1f3e29..f11c4f0352 100644 --- a/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp +++ b/distributed_camera/hdi_service/src/dcamera_device/dmetadata_processor.cpp @@ -235,7 +235,7 @@ void DMetadataProcessor::InitOutputAbilityWithoutMode(const std::string &sinkAbi std::vector streamConfigs; std::vector extendStreamConfigs; - for (int32_t i = 0; i < ADD_MODE; i++) { // Compatible camera framework modification + for (uint32_t i = 0; i < ADD_MODE; i++) { // Compatible camera framework modification camera_metadata_item_t item; int ret = OHOS::Camera::FindCameraMetadataItem(dCameraAbility_->get(), OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &item); @@ -253,8 +253,8 @@ void DMetadataProcessor::InitOutputAbilityWithoutMode(const std::string &sinkAbi DCamRetCode DMetadataProcessor::InitDCameraOutputAbilityKeys(const std::string &sinkAbilityInfo) { cJSON *rootValue = cJSON_Parse(sinkAbilityInfo.c_str()); - CHECK_AND_RETURN_RET_LOG(rootValue == nullptr || !cJSON_IsObject(rootValue), FAILED, - "sinkAbilityInfo parse error."); + CHECK_NULL_RETURN_LOG(rootValue, FAILED, "The sinkAbilityInfo is null."); + CHECK_OBJECT_FREE_RETURN(rootValue, FAILED, "The sinkAbilityInfo is not object."); cJSON *modeArray = cJSON_GetObjectItemCaseSensitive(rootValue, CAMERA_SUPPORT_MODE.c_str()); if (modeArray == nullptr || !cJSON_IsArray(modeArray)) { @@ -285,7 +285,7 @@ DCamRetCode DMetadataProcessor::InitDCameraOutputAbilityKeys(const std::string & std::map> supportedFormats = GetDCameraSupportedFormats(format); camera_metadata_item_t item; - int ret = OHOS::Camera::FindCameraMetadataItem(dCameraAbility_->get(), + int32_t ret = OHOS::Camera::FindCameraMetadataItem(dCameraAbility_->get(), OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &item); if (ret == CAM_META_SUCCESS && item.count != 0) { extendStreamConfigs.push_back(std::stoi(key)); // mode -- Gitee From e5e49dc64a5a788f79bd7d975469bd85ac2cd9c5 Mon Sep 17 00:00:00 2001 From: liufeng Date: Wed, 7 Aug 2024 13:49:42 +0800 Subject: [PATCH 0089/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp | 42 +- .../v1_2/src/front_camera_hdi_uttest_v1_2.cpp | 90 ++-- camera/test/hdi/v1_2/src/hdi_common_v1_2.cpp | 4 +- .../hdi/v1_3/src/camera_front_uttest_v1_3.cpp | 8 +- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 187 ++++---- .../src/camera_professional_uttest_v1_3.cpp | 412 ++++++++++-------- camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp | 4 +- 7 files changed, 408 insertions(+), 339 deletions(-) diff --git a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp index d136428b8e..16d2f61301 100644 --- a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp @@ -45,6 +45,7 @@ bool IsTagValueExistsU8(std::shared_ptr ability, uint32_t tag, u int ret = FindCameraMetadataItem(data, tag, &entry); EXPECT_EQ(ret, 0); EXPECT_NE(entry.count, 0); + EXPECT_TRUE(entry.data.u8 != nullptr); for (int i = 0; i < entry.count; i++) { if (entry.data.u8[i] == value) { return true; @@ -520,10 +521,10 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_012, TestSize.Level1) common_metadata_header_t* data = cameraTest->ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_SUPPORTED_COLOR_MODES, &entry); - if (ret == 0) { - EXPECT_TRUE(entry.data.u8 != nullptr); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { CAMERA_LOGI("OHOS_ABILITY_SUPPORTED_COLOR_MODES: %{public}d", entry.data.u8[0]); } else { + print("XMage not supported\n"); CAMERA_LOGI("XMage not supported"); } } @@ -678,7 +679,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_016, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME, &entry); cameraTest->imageDataSaveSwitch = SWITCH_ON; - if (ret == HDI::Camera::V1_0::NO_ERROR && entry.count > 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { CAMERA_LOGI("print tag f value start."); for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); @@ -694,7 +695,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_016, TestSize.Level1) } CAMERA_LOGI("print tag f value end."); } else { - CAMERA_LOGI("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME value count is 0"); + CAMERA_LOGE("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME not supported"); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -713,7 +714,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_017, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME, &entry); cameraTest->imageDataSaveSwitch = SWITCH_ON; - if (ret == HDI::Camera::V1_0::NO_ERROR && entry.count > 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { CAMERA_LOGI("print tag f value start."); for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); @@ -729,7 +730,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_017, TestSize.Level1) } CAMERA_LOGI("print tag f value end."); } else { - CAMERA_LOGI("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME value count is 0"); + CAMERA_LOGE("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME not supported"); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -855,6 +856,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_022, TestSize.Level1) EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); EXPECT_EQ(META_TYPE_BYTE, entry.data_type); + EXPECT_TRUE(entry.data.u8 != nullptr); for (int i = 0; i < entry.count; i++) { if (entry.data.u8[i] == OHOS_CAMERA_VIDEO_STABILIZATION_OFF) { CAMERA_LOGI("OHOS_CAMERA_VIDEO_STABILIZATION_OFF found!"); @@ -1622,17 +1624,23 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_052, TestSize.Level1) camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME, &entry); EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - for (size_t i = 0; i < entry.count; i++) { - printf("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME:%d\n", entry.data.i32[i]); - - //update settings - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - int32_t manualExposureTime = entry.data.i32[i]; - meta->addEntry(OHOS_CONTROL_MANUAL_EXPOSURE_TIME, &manualExposureTime, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); + if (entry.data.i32 != nullptr && entry.count > 0) { + for (size_t i = 0; i < entry.count; i++) { + printf("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME:%d\n", entry.data.i32[i]); + + //update settings + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + int32_t manualExposureTime = entry.data.i32[i]; + meta->addEntry(OHOS_CONTROL_MANUAL_EXPOSURE_TIME, &manualExposureTime, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + } + } else { + CAMERA_LOGI("NIGHT_MODE data can't find!"); + printf("NIGHT_MODE data can't find!\n"); } } diff --git a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp index 95e60a5541..1fcb93f782 100644 --- a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp @@ -104,49 +104,51 @@ HWTEST_F(FrontCameraHdiUtTestV1_2, Front_Camera_Device_Hdi_V1_2_002, TestSize.Le camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_VIRTUAL_APERTURE_RANGE, &entry); - for (size_t i = 0; i < entry.count; i++) { - // Get Stream Operator - cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback(); - cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback, - cameraTest->streamOperator_V1_1); - EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - // preview streamInfo - cameraTest->streamInfoV1_1 = std::make_shared(); - cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); - - // capture streamInfo - cameraTest->streamInfoV1_1 = std::make_shared(); - cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1); - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); - - // create and commitstreams - cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1( - static_cast(OHOS::HDI::Camera::V1_2::PORTRAIT), - cameraTest->abilityVec); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - //update settings - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - float virtualApertureValue = entry.data.f[i]; - meta->addEntry(OHOS_CONTROL_CAMERA_VIRTUAL_APERTURE_VALUE, &virtualApertureValue, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - // start capture - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true); - - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); - sleep(1); - cameraTest->streamInfosV1_1.clear(); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (size_t i = 0; i < entry.count; i++) { + // Get Stream Operator + cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback(); + cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback, + cameraTest->streamOperator_V1_1); + EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + // preview streamInfo + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + + // capture streamInfo + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + + // create and commitstreams + cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1( + static_cast(OHOS::HDI::Camera::V1_2::PORTRAIT), + cameraTest->abilityVec); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + //update settings + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + float virtualApertureValue = entry.data.f[i]; + meta->addEntry(OHOS_CONTROL_CAMERA_VIRTUAL_APERTURE_VALUE, &virtualApertureValue, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + // start capture + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true); + + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + sleep(1); + cameraTest->streamInfosV1_1.clear(); + } } } diff --git a/camera/test/hdi/v1_2/src/hdi_common_v1_2.cpp b/camera/test/hdi/v1_2/src/hdi_common_v1_2.cpp index 6575f74d59..beb64abe5d 100644 --- a/camera/test/hdi/v1_2/src/hdi_common_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/hdi_common_v1_2.cpp @@ -299,7 +299,7 @@ void Test::DefaultInfosAnalyze( camera_metadata_item_t entry = {}; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face ids : %{public}d", id); @@ -307,7 +307,7 @@ void Test::DefaultInfosAnalyze( } ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face rectangles : %{public}d", id); diff --git a/camera/test/hdi/v1_3/src/camera_front_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_front_uttest_v1_3.cpp index eed7dcb685..763c7a59d9 100644 --- a/camera/test/hdi/v1_3/src/camera_front_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_front_uttest_v1_3.cpp @@ -48,9 +48,7 @@ HWTEST_F(CameraFrontUtTestV1_3, Camera_Front_Hdi_V1_3_001, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); - if (ret == HDI::Camera::V1_0::NO_ERROR) { - EXPECT_TRUE(entry.data.u8 != nullptr); - EXPECT_TRUE(entry.count > 0); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { uint8_t captureMirror = entry.data.u8[i]; if (captureMirror == OHOS_CAMERA_MIRROR_CAPTURE) { @@ -94,9 +92,7 @@ HWTEST_F(CameraFrontUtTestV1_3, Camera_Front_Hdi_V1_3_002, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); - if (ret == HDI::Camera::V1_0::NO_ERROR) { - EXPECT_TRUE(entry.data.u8 != nullptr); - EXPECT_TRUE(entry.count > 0); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { uint8_t captureMirror = entry.data.u8[i]; if (captureMirror == OHOS_CAMERA_MIRROR_CAPTURE) { diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 0f4e8b3580..366c147a34 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -49,12 +49,15 @@ bool IsTagValueExistsU8(std::shared_ptr ability, uint32_t tag, u common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == value) { - return true; + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } } + } else { + printf("Find CameraMetadata fail!\n"); + CAMERA_LOGE("Find CameraMetadata fail!"); } return false; } @@ -64,12 +67,15 @@ void PrintAllTagDataU8(std::shared_ptr ability, uint32_t tag) common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - cout << "----tag = " << tag << "count = " << entry.count << endl; - for (int i = 0; i < entry.count; i++) { - int v = entry.data.u8[i]; - cout << "tag[" << tag << "][" << i << "] = " << v << endl; + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + cout << "----tag = " << tag << "count = " << entry.count << endl; + for (int i = 0; i < entry.count; i++) { + int v = entry.data.u8[i]; + cout << "tag[" << tag << "][" << i << "] = " << v << endl; + } + } else { + printf("Print tag data fail!\n"); + CAMERA_LOGE("Print tag data fail!"); } cout << "--------------------------------" << endl; } @@ -138,7 +144,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_002, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { EXPECT_TRUE(entry.data.u8 != nullptr); for (size_t i = 0; i < entry.count; i++ ) { @@ -287,7 +292,6 @@ static void SuperSlowMotionStatusCallback(std::shared_ptr ca EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_SLOW_MOTION_DETECTION, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { uint8_t value = entry.data.u8[0]; // Detect the state of super slow motion @@ -317,7 +321,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_005, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { EXPECT_TRUE(entry.data.u8 != nullptr); for (size_t i = 0; i < entry.count; i++ ) { @@ -386,7 +389,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_007, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { EXPECT_TRUE(entry.data.u8 != nullptr); if (entry.data.u8[0] == OHOS_CAMERA_MOTION_DETECTION_SUPPORTED) { @@ -582,6 +584,7 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_011, TestSize.Level1) camera_metadata_item_t callbackEntry; cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &callbackEntry); EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + EXPECT_NE(callbackEntry.data.ui32, nullptr); printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]); } @@ -1250,13 +1253,18 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_033, TestSize.Level1) CAMERA_LOGI("print tag value start."); constexpr size_t step = 20; // print step std::stringstream ss; - for (size_t i = 0; i < entry.count; i++) { - ss << entry.data.i32[i] << " "; - if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { - CAMERA_LOGI("%{public}s\n", ss.str().c_str()); - ss.clear(); - ss.str(""); + if (entry.data.i32 != nullptr && entry.count > 0) { + for (size_t i = 0; i < entry.count; i++) { + ss << entry.data.i32[i] << " "; + if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { + CAMERA_LOGI("%{public}s\n", ss.str().c_str()); + ss.clear(); + ss.str(""); + } } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } CAMERA_LOGI("print tag value end."); } @@ -1281,13 +1289,18 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_034, TestSize.Level1) CAMERA_LOGI("print tag value start."); constexpr size_t step = 20; // print step std::stringstream ss; - for (size_t i = 0; i < entry.count; i++) { - ss << entry.data.i32[i] << " "; - if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { - CAMERA_LOGI("%{public}s\n", ss.str().c_str()); - ss.clear(); - ss.str(""); + if (entry.data.i32 != nullptr && entry.count > 0) { + for (size_t i = 0; i < entry.count; i++) { + ss << entry.data.i32[i] << " "; + if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { + CAMERA_LOGI("%{public}s\n", ss.str().c_str()); + ss.clear(); + ss.str(""); + } } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } CAMERA_LOGI("print tag value end."); } @@ -1312,13 +1325,18 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_035, TestSize.Level1) CAMERA_LOGI("print tag value start."); constexpr size_t step = 20; // print step std::stringstream ss; - for (size_t i = 0; i < entry.count; i++) { - ss << entry.data.i32[i] << " "; - if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { - CAMERA_LOGI("%{public}s\n", ss.str().c_str()); - ss.clear(); - ss.str(""); + if (entry.data.i32 != nullptr && entry.count > 0) { + for (size_t i = 0; i < entry.count; i++) { + ss << entry.data.i32[i] << " "; + if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { + CAMERA_LOGI("%{public}s\n", ss.str().c_str()); + ss.clear(); + ss.str(""); + } } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } CAMERA_LOGI("print tag value end."); } @@ -1336,7 +1354,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_036, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) { EXPECT_NE(entry.data.u8, nullptr); EXPECT_EQ(entry.count > 0, true); @@ -1547,59 +1564,63 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_040, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SUPPORTED_COLOR_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->imageDataSaveSwitch = SWITCH_ON; - for (uint8_t i = 0; i < entry.count; i++) { - // Get stream operator - cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); - cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3, - cameraTest->streamOperator_V1_3); - EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - // Preview streamInfo - cameraTest->streamInfoV1_1 = std::make_shared(); - cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); - cameraTest->streamInfoV1_1->v1_0.width_ = 4096; - cameraTest->streamInfoV1_1->v1_0.height_ = 3072; - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - cameraTest->streamInfoCapture = std::make_shared(); - cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); - cameraTest->streamInfoCapture->v1_0.width_ = 4096; - cameraTest->streamInfoCapture->v1_0.height_ = 3072; - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); - // Create and commitStream - cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1( - static_cast(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING), - cameraTest->abilityVec); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->imageDataSaveSwitch = SWITCH_ON; + for (uint8_t i = 0; i < entry.count; i++) { + // Get stream operator + cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); + cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3, + cameraTest->streamOperator_V1_3); + EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + // Preview streamInfo + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); + cameraTest->streamInfoV1_1->v1_0.width_ = 4096; + cameraTest->streamInfoV1_1->v1_0.height_ = 3072; + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); - // Update settings - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t xmageMode = entry.data.u8[i]; - meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true); + cameraTest->streamInfoCapture = std::make_shared(); + cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); + cameraTest->streamInfoCapture->v1_0.width_ = 4096; + cameraTest->streamInfoCapture->v1_0.height_ = 3072; + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); + // Create and commitStream + cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1( + static_cast(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING), + cameraTest->abilityVec); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + // Update settings + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t xmageMode = entry.data.u8[i]; + meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true); - sleep(UT_SLEEP_TIME); - EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); - cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture); + sleep(UT_SLEEP_TIME); + EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); + cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); - sleep(UT_SLEEP_TIME); - cameraTest->streamInfosV1_1.clear(); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + sleep(UT_SLEEP_TIME); + cameraTest->streamInfosV1_1.clear(); + } + cameraTest->imageDataSaveSwitch = SWITCH_OFF; + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } - cameraTest->imageDataSaveSwitch = SWITCH_OFF; } /** @@ -1615,7 +1636,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_041, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) { EXPECT_NE(entry.data.u8, nullptr); EXPECT_EQ(entry.count > 0, true); @@ -1860,7 +1880,6 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_046, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) { EXPECT_NE(entry.data.u8, nullptr); EXPECT_EQ(entry.count > 0, true); diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 4ea7a61a91..50a19ae582 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -52,10 +52,15 @@ bool g_isModeExists(std::shared_ptr ability, uint32_t tag, uint8 int ret = FindCameraMetadataItem(data, tag, &entry); EXPECT_EQ(ret, 0); EXPECT_NE(entry.count, 0); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == value) { - return true; + if (entry.data.u8 != nullptr) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } } + } else { + printf("Find CameraMetadata fail!\n"); + CAMERA_LOGE("Find CameraMetadata fail!"); } return false; } @@ -69,6 +74,7 @@ void GetSupportedPhysicalApertureValues(std::shared_ptr ability) camera_metadata_item_t entry; int rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry); EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, rc); + EXPECT_TRUE(entry.data.f != nullptr); float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10], entry.data.f[14], entry.data.f[18]}; for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) { @@ -102,7 +108,6 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_001, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { EXPECT_TRUE(entry.data.u8 != nullptr); for (size_t i = 0; i < entry.count; i++) { @@ -319,7 +324,6 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_006, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_ASSIST_FLASH_SUPPORTED_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0;i < entry.count;i++) { if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT) { @@ -409,7 +413,6 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_008, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0;i < entry.count;i++) { if (entry.data.u8[i] == OHOS_CAMERA_SPOT_METERING) { @@ -652,7 +655,6 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_013, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0;i < entry.count;i++) { if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) { @@ -712,25 +714,29 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_014, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, STILL_CAPTURE}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - float lensFocusDistance = entry.data.f[i]; - meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + float lensFocusDistance = entry.data.f[i]; + meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -754,44 +760,48 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_015, TestSiz common_metadata_header_t* data = cameraTest->ability->get(); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - for (size_t i = 0;i < entry.count;i++) { - if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_OFF) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_OFF mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_AUTO) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_AUTO mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_INCANDESCENT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_INCANDESCENT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_FLUORESCENT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_FLUORESCENT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_DAYLIGHT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_DAYLIGHT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_TWILIGHT) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_TWILIGHT mode is supported!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_SHADE) { - CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_SHADE mode is supported!"); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (size_t i = 0;i < entry.count;i++) { + if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_OFF) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_OFF mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_AUTO) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_AUTO mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_INCANDESCENT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_INCANDESCENT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_FLUORESCENT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_FLUORESCENT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_DAYLIGHT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_DAYLIGHT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_TWILIGHT) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_TWILIGHT mode is supported!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_SHADE) { + CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_SHADE mode is supported!"); + } + + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t awbMode = entry.data.u8[i]; + meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } - - cameraTest->intents = {PREVIEW, STILL_CAPTURE}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t awbMode = entry.data.u8[i]; - meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; @@ -865,25 +875,29 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_017, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, STILL_CAPTURE}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - int32_t wbMode = entry.data.i32[i]; - meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + int32_t wbMode = entry.data.i32[i]; + meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -1019,24 +1033,29 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_021, TestSiz EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t meteringMode = entry.data.u8[i]; - meta->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t meteringMode = entry.data.u8[i]; + meta->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -1146,23 +1165,28 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_024, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, &entry); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - camera_rational_t sensorExposureTime = {entry.data.r[i].numerator, entry.data.r[i].denominator}; - meta->addEntry(OHOS_CONTROL_SENSOR_EXPOSURE_TIME, &sensorExposureTime, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.r != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + camera_rational_t sensorExposureTime = {entry.data.r[i].numerator, entry.data.r[i].denominator}; + meta->addEntry(OHOS_CONTROL_SENSOR_EXPOSURE_TIME, &sensorExposureTime, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; @@ -1229,27 +1253,32 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_026, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t focusMode = entry.data.u8[i]; - meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT); - if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) { - uint8_t focusedPoint[] = {1, 1, 1, 1}; - meta->addEntry(OHOS_CONTROL_FOCUSED_POINT, &focusedPoint, DATA_COUNT); + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t focusMode = entry.data.u8[i]; + meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT); + if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_MODE_MANUAL) { + uint8_t focusedPoint[] = {1, 1, 1, 1}; + meta->addEntry(OHOS_CONTROL_FOCUSED_POINT, &focusedPoint, DATA_COUNT); + } + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -1274,23 +1303,28 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_027, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - float lensFocusDistance = entry.data.f[i]; - meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + float lensFocusDistance = entry.data.f[i]; + meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -1315,23 +1349,28 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_028, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t awbMode = entry.data.u8[i]; - meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t awbMode = entry.data.u8[i]; + meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } @@ -1356,23 +1395,28 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_029, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry); - for (uint8_t i = 0;i < entry.count;i++) { - cameraTest->intents = {PREVIEW, VIDEO}; - cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); - - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - int32_t wbMode = entry.data.i32[i]; - meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + for (uint8_t i = 0;i < entry.count;i++) { + cameraTest->intents = {PREVIEW, VIDEO}; + cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); + + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + int32_t wbMode = entry.data.i32[i]; + meta->addEntry(OHOS_CONTROL_SENSOR_WB_VALUE, &wbMode, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } cameraTest->imageDataSaveSwitch = SWITCH_OFF; } diff --git a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp index 982ac12878..6748313044 100644 --- a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp @@ -282,7 +282,7 @@ void Test::DefaultInfosAnalyze( camera_metadata_item_t entry = {}; int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face ids : %{public}d", id); @@ -290,7 +290,7 @@ void Test::DefaultInfosAnalyze( } ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry); - if (ret == 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { int id = entry.data.i32[i]; CAMERA_LOGI("Face rectangles : %{public}d", id); -- Gitee From e45faeddb7da163d42a19f429e376c3938499705 Mon Sep 17 00:00:00 2001 From: chenjunwu Date: Wed, 7 Aug 2024 16:15:09 +0800 Subject: [PATCH 0090/1485] fix: Component dependent rectification Signed-off-by: chenjunwu --- .../test/fuzztest/batteryhdistub_fuzzer/BUILD.gn | 6 ++---- .../interfaces/hdi_service/test/systemtest/BUILD.gn | 7 +++---- battery/interfaces/hdi_service/test/unittest/BUILD.gn | 11 +++++------ 3 files changed, 10 insertions(+), 14 deletions(-) diff --git a/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/BUILD.gn b/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/BUILD.gn index ad6f01d952..11ce3f2ff6 100644 --- a/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/BUILD.gn +++ b/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/BUILD.gn @@ -31,13 +31,11 @@ ohos_fuzztest("BatteryHdiStubFuzzTest") { ] sources = [ "batteryhdistub_fuzz.cpp" ] - deps = [ - "../../../:libbattery_interface_service_2.0", - "../../../../../../../interface/battery/v2_0:libbattery_stub_2.0", - ] + deps = [ "../../../:libbattery_interface_service_2.0" ] external_deps = [ "drivers_interface_battery:libbattery_proxy_2.0", + "drivers_interface_battery:libbattery_stub_2.0", "hdf_core:libhdf_utils", "hdf_core:libhdi", "hilog:libhilog", diff --git a/battery/interfaces/hdi_service/test/systemtest/BUILD.gn b/battery/interfaces/hdi_service/test/systemtest/BUILD.gn index d8a830ca5b..0c231a1776 100644 --- a/battery/interfaces/hdi_service/test/systemtest/BUILD.gn +++ b/battery/interfaces/hdi_service/test/systemtest/BUILD.gn @@ -43,15 +43,14 @@ ohos_systemtest("test_battery_sys_test") { configs = [ ":module_private_config" ] - deps = [ - "//third_party/googletest:gtest_main", - "//third_party/jsoncpp:jsoncpp", - ] + deps = [] external_deps = [ "config_policy:configpolicy_util", + "googletest:gtest_main", "hdf_core:libpub_utils", "hilog:libhilog", + "jsoncpp:jsoncpp", ] if (has_battery_c_utils_part) { external_deps += [ "c_utils:utils" ] diff --git a/battery/interfaces/hdi_service/test/unittest/BUILD.gn b/battery/interfaces/hdi_service/test/unittest/BUILD.gn index 3f5e0fc9d8..761bf76503 100644 --- a/battery/interfaces/hdi_service/test/unittest/BUILD.gn +++ b/battery/interfaces/hdi_service/test/unittest/BUILD.gn @@ -41,15 +41,14 @@ ohos_unittest("test_hdisrv") { configs = [ ":module_private_config" ] - deps = [ - "../../../../../../interface/battery/v2_0:libbattery_stub_2.0", - "//third_party/cJSON:cjson", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] + deps = [] external_deps = [ + "cJSON:cjson", "config_policy:configpolicy_util", + "drivers_interface_battery:libbattery_stub_2.0", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", -- Gitee From 014f0c9c99d670de535c27859979a9d655d7b03e Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Tue, 6 Aug 2024 08:10:59 +0000 Subject: [PATCH 0091/1485] modify sequ Signed-off-by: yuzhiqiang --- usb/ddk/host/src/usb_interface_pool.c | 2 +- usb/hdi_service/include/usb_impl.h | 1 + usb/hdi_service/src/usb_impl.cpp | 23 ++++++++++++----------- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index 298417d475..fc94859008 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -176,11 +176,11 @@ static HDF_STATUS IfFreeInterfacePool(struct UsbInterfacePool *interfacePool) return ret; } OsalMutexDestroy(&interfacePool->interfaceLock); + OsalMutexDestroy(&interfacePool->ioStopLock); interfacePool->busNum = 0; interfacePool->devAddr = 0; RawUsbMemFree(interfacePool); - OsalMutexDestroy(&interfacePool->ioStopLock); return ret; } diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index 171798d196..1f549b22c1 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -93,6 +93,7 @@ public: static int32_t UsbdRequestSyncReleaseList(HostDevice *port); static int32_t UsbdRequestASyncReleaseList(HostDevice *port); + static int32_t UsbdBulkASyncListReleasePort(HostDevice *port); static int32_t UsbdRequestASyncReleaseData(UsbdRequestASync *request); static UsbInterfaceHandle *InterfaceIdToHandle(const HostDevice *dev, uint8_t id); diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 2db8b09a66..5202ddad22 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -416,8 +416,7 @@ int32_t UsbImpl::UsbdFindRequestSyncAndCreatwithLength(HostDevice *port, uint8_t *request = requestSync; return HDF_SUCCESS; } else { - HdfSListRemove(&port->reqASyncList, &requestSync->node); - UsbdDispatcher::UsbdRequestSyncRelease(requestSync); + UsbdRequestSyncReleaseList(port); HDF_LOGD("%{public}s:ifId:%{public}u, epId:%{public}u,realloc reqeustsync.", __func__, interfaceId, pipeAddr); } @@ -1379,18 +1378,20 @@ int32_t UsbImpl::ReleaseInterface(const UsbDev &dev, uint8_t interfaceId) return HDF_DEV_ERR_NO_DEVICE; } - if (interfaceId == MAX_INTERFACEID) { - if (port->ctrIface != nullptr) { - UsbReleaseInterface(port->ctrIface); - port->ctrIface = nullptr; + if (interfaceId < USB_MAX_INTERFACES) { + if (HdfSListCount(&port->reqSyncList) > 0) { + UsbdRequestSyncReleaseList(port); + HDF_LOGD("%{public}s:release sync list", __func__); + } + if (HdfSListCount(&port->reqASyncList) > 0) { + UsbdRequestASyncReleaseList(port); + HDF_LOGD("%{public}s:release async list", __func__); } - if (port->ctrDevHandle != nullptr) { - UsbCloseInterface(port->ctrDevHandle, false); - port->ctrDevHandle = nullptr; + int32_t ret = UsbdBulkASyncListReleasePort(port); + if (ret != HDF_SUCCESS) { + HDF_LOGW("%{public}s:release bulk async list failed", __func__); } - return HDF_SUCCESS; - } else if (interfaceId < USB_MAX_INTERFACES) { if (port->iface[interfaceId] != nullptr) { UsbReleaseInterface(port->iface[interfaceId]); port->iface[interfaceId] = nullptr; -- Gitee From 0bbbcd09f6f65797700c99bc50c1b94f620b8ca9 Mon Sep 17 00:00:00 2001 From: liufeng Date: Wed, 7 Aug 2024 17:52:32 +0800 Subject: [PATCH 0092/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../v1_2/src/front_camera_hdi_uttest_v1_2.cpp | 2 +- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 4 ++-- .../src/camera_professional_uttest_v1_3.cpp | 19 ++++++++++++------- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp index 1fcb93f782..b874a7001b 100644 --- a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp @@ -104,7 +104,7 @@ HWTEST_F(FrontCameraHdiUtTestV1_2, Front_Camera_Device_Hdi_V1_2_002, TestSize.Le camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_VIRTUAL_APERTURE_RANGE, &entry); - if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { // Get Stream Operator cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback(); diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 366c147a34..021a7eed4b 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -1570,8 +1570,8 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_040, TestSize.Level1) for (uint8_t i = 0; i < entry.count; i++) { // Get stream operator cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); - cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3, - cameraTest->streamOperator_V1_3); + cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( + cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); // Preview streamInfo diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 50a19ae582..fa3435c75a 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -65,7 +65,7 @@ bool g_isModeExists(std::shared_ptr ability, uint32_t tag, uint8 return false; } -void GetSupportedPhysicalApertureValues(std::shared_ptr ability) +bool GetSupportedPhysicalApertureValues(std::shared_ptr ability) { supportedPhysicalApertureValues_.clear(); EXPECT_NE(ability, nullptr); @@ -73,12 +73,17 @@ void GetSupportedPhysicalApertureValues(std::shared_ptr ability) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; int rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, rc); - EXPECT_TRUE(entry.data.f != nullptr); - float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10], - entry.data.f[14], entry.data.f[18]}; - for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) { - supportedPhysicalApertureValues_.push_back(entryValues[i]); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10], + entry.data.f[14], entry.data.f[18]}; + for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) { + supportedPhysicalApertureValues_.push_back(entryValues[i]); + } + return true; + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); + return false; } } -- Gitee From 44ac798dcd1699f83ade259c4eb465ccc8b5dd4e Mon Sep 17 00:00:00 2001 From: liangqi Date: Wed, 7 Aug 2024 17:51:58 +0800 Subject: [PATCH 0093/1485] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liangqi --- .../test/unittest/udriver/hdi_input_test.cpp | 111 +++++++++++++++++- 1 file changed, 110 insertions(+), 1 deletion(-) diff --git a/input/test/unittest/udriver/hdi_input_test.cpp b/input/test/unittest/udriver/hdi_input_test.cpp index 409209133d..341d344503 100644 --- a/input/test/unittest/udriver/hdi_input_test.cpp +++ b/input/test/unittest/udriver/hdi_input_test.cpp @@ -50,6 +50,7 @@ static const uint32_t INIT_DEFAULT_VALUE = 255; static const uint32_t STATUS = INPUT_DEVICE_STATUS_CLOSED; static const string NODE_PATH = "dev/input/"; static const size_t COUNT = 1; +static const size_t INVALID_DEV_INDEX = 33; class HdiInputTest : public testing::Test { @@ -381,6 +382,24 @@ HWTEST_F(HdiInputTest, RegisterCallbackAndReportData001, TestSize.Level1) OsalMSleep(KEEP_ALIVE_TIME_MS); } +/** + * @tc.name: RegisterReportCallback001 + * @tc.desc: register report callback fail + * @tc.type: FUNC + * @tc.require: AR000F8682, AR000F8QNL + */ +HWTEST_F(HdiInputTest, RegisterReportCallback001, TestSize.Level1) +{ + printf("%s: [Input] RegisterReportCallback001 enter\n", __func__); + InputDeviceManager iInputDeviceManager; + int32_t ret; + ret = iInputDeviceManager.RegisterReportCallback(0, nullptr); + if (ret != INPUT_SUCCESS) { + printf("%s: register report callback failed, ret %d\n", __func__, ret); + } + EXPECT_NE(ret, INPUT_SUCCESS); +} + /** * @tc.name: UnregisterReportCallback001 * @tc.desc: get input device chip info test @@ -407,6 +426,25 @@ HWTEST_F(HdiInputTest, UnregisterReportCallback001, TestSize.Level1) EXPECT_EQ(ret, INPUT_SUCCESS); } +/** + * @tc.name: UnRegisterReportCallback001 + * @tc.desc: unregister report callback fail + * @tc.type: FUNC + * @tc.require: AR000F8682, AR000F8QNL + */ +HWTEST_F(HdiInputTest, UnRegisterReportCallback001, TestSize.Level1) +{ + printf("%s: [Input] UnRegisterReportCallback001 enter\n", __func__); + int32_t ret; + InputDeviceManager iInputDeviceManager; + ret = iInputDeviceManager.UnregisterReportCallback(INVALID_DEV_INDEX); + if (ret != INPUT_SUCCESS) { + printf("%s: unregister report callback failed, ret %d\n", __func__, ret); + } + EXPECT_NE(ret, INPUT_SUCCESS); +} + + /** * @tc.name: FindIndexFromFd * @tc.desc: find index from fd test @@ -889,6 +927,28 @@ HWTEST_F(HdiInputTest, RunCapacitanceTest001, TestSize.Level1) EXPECT_EQ(ret, INPUT_SUCCESS); } +/** + * @tc.name: RunCapacitanceTest002 + * @tc.desc: run capacitance test test002 + * @tc.type: FUNC + * @tc.require: SR000F867Q + */ +HWTEST_F(HdiInputTest, RunCapacitanceTest002, TestSize.Level1) +{ + printf("%s: [Input] RunCapacitanceTest002 enter\n", __func__); + INPUT_CHECK_NULL_POINTER(g_inputInterface, INPUT_NULL_PTR); + INPUT_CHECK_NULL_POINTER(g_inputInterface->iInputController, INPUT_NULL_PTR); + + int32_t ret; + char result[TEST_RESULT_LEN] = {0}; + uint32_t testType = TEST_TYPE; + ret = g_inputInterface->iInputController->RunCapacitanceTest(g_touchIndex, testType, nullptr, TEST_RESULT_LEN); + if (ret != INPUT_SUCCESS) { + HDF_LOGE("%s: run capacitance test002 failed, ret %d", __func__, ret); + } + EXPECT_NE(ret, INPUT_SUCCESS); +} + /** * @tc.name: RunExtraCommand * @tc.desc: run extra command test @@ -1015,7 +1075,7 @@ HWTEST_F(HdiInputTest, DoWithEventDeviceDel001, TestSize.Level1) } /** - * @tc.name: ReportEventPkg + * @tc.name: ReportEventPkg001 * @tc.desc: Report Event Pkg * @tc.type: FUNC * @tc.require: SR000F867Q @@ -1029,6 +1089,19 @@ HWTEST_F(HdiInputTest, ReportEventPkg001, TestSize.Level1) iInputDeviceManager.ReportEventPkg(g_fileDescriptorFirst, evtPkg, COUNT); } +/** + * @tc.name: ReportEventPkg002 + * @tc.desc: Report Event Pkg + * @tc.type: FUNC + * @tc.require: SR000F867Q + */ +HWTEST_F(HdiInputTest, ReportEventPkg002, TestSize.Level1) +{ + printf("%s: [Input] ReportEventPkg002 enter\n", __func__); + InputDeviceManager iInputDeviceManager; + iInputDeviceManager.ReportEventPkg(g_fileDescriptorFirst, nullptr, COUNT); +} + /** * @tc.name: DoRead * @tc.desc: Do Read @@ -1061,3 +1134,39 @@ HWTEST_F(HdiInputTest, InotifyEventHandler001, TestSize.Level1) } EXPECT_EQ(ret, INPUT_SUCCESS); } + +/** + * @tc.name: ScanDevice + * @tc.desc: Scan Device Fail + * @tc.type: FUNC + * @tc.require: SR000F867Q + */ +HWTEST_F(HdiInputTest, ScanDevice001, TestSize.Level1) +{ + printf("%s: [Input] ScanDevice001 enter\n", __func__); + int32_t ret; + InputDeviceManager iInputDeviceManager; + ret = iInputDeviceManager.ScanDevice(nullptr, 0); + if (ret != INPUT_SUCCESS) { + printf("%s: Scan Device failed, ret %d\n", __func__, ret); + } + EXPECT_NE(ret, INPUT_SUCCESS); +} + +/** + * @tc.name: GetDeviceList + * @tc.desc: Get Device List Fail + * @tc.type: FUNC + * @tc.require: SR000F867Q + */ +HWTEST_F(HdiInputTest, GetDeviceList001, TestSize.Level1) +{ + printf("%s: [Input] GetDeviceList001 enter\n", __func__); + int32_t ret; + InputDeviceManager iInputDeviceManager; + ret = iInputDeviceManager.GetDeviceList(nullptr, nullptr, 0); + if (ret != INPUT_SUCCESS) { + printf("%s: Get Device List Failed, ret %d\n", __func__, ret); + } + EXPECT_NE(ret, INPUT_SUCCESS); +} -- Gitee From 47e01f290f9886a4e5181e7cc67825ede48fceed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=AB=98=E5=85=B4=E7=83=A8?= Date: Wed, 7 Aug 2024 19:41:42 +0800 Subject: [PATCH 0094/1485] send action bugfix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 高兴烨 --- wlan/client/src/netlink/netlink_cmd_adapter.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index 1933892cce..29b3f9884c 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -3324,7 +3324,8 @@ int32_t WifiSendActionFrame(const char *ifName, uint32_t freq, const uint8_t *fr HILOG_ERROR(LOG_CORE, "%{public}s: nla_put_u32 freq failed", __FUNCTION__); break; } - if (nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK) != RET_CODE_SUCCESS) { + if (strncmp(ifName, STR_CHBA, strlen(STR_CHBA)) != 0 && + nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK) != RET_CODE_SUCCESS) { HILOG_ERROR(LOG_CORE, "%{public}s: nla_put_u32 offchannel failed", __FUNCTION__); break; } -- Gitee From 30c2fcadc20091740c82ed4174a4b389e0d138ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 8 Aug 2024 02:23:25 +0000 Subject: [PATCH 0095/1485] update audio/hal/hdi_binder/server/src/hdf_audio_server_render.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hal/hdi_binder/server/src/hdf_audio_server_render.c | 1 + 1 file changed, 1 insertion(+) diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c index ec2cc53980..d984c5d181 100644 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c @@ -716,6 +716,7 @@ int32_t HdiServiceRenderRenderFrame(const struct HdfDeviceIoClient *client, (void)OsalMutexLock(&g_renderLock); if (render == NULL || render->RenderFrame == NULL) { AUDIO_FUNC_LOGE("render or RenderFrame is NULL"); + (void)OsalMutexUnlock(&g_renderLock); return AUDIO_HAL_ERR_INTERNAL; } ret = render->RenderFrame((AudioHandle)render, (const void *)frame, (uint64_t)requestBytes, &replyBytes); -- Gitee From f18740b1788e1659ecd3ab311eafa209c0ed9065 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 8 Aug 2024 02:24:35 +0000 Subject: [PATCH 0096/1485] update audio/hal/hdi_binder/server/src/hdf_audio_server_render.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hal/hdi_binder/server/src/hdf_audio_server_render.c | 1 + 1 file changed, 1 insertion(+) diff --git a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c index d984c5d181..eadaf16dcc 100644 --- a/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c +++ b/audio/hal/hdi_binder/server/src/hdf_audio_server_render.c @@ -745,6 +745,7 @@ int32_t HdiServiceRenderGetRenderPosition(const struct HdfDeviceIoClient *client (void)OsalMutexLock(&g_renderLock); if (render == NULL || render->GetRenderPosition == NULL) { AUDIO_FUNC_LOGE("render or GetRenderPosition is NULL"); + (void)OsalMutexUnlock(&g_renderLock); return AUDIO_HAL_ERR_INTERNAL; } ret = render->GetRenderPosition((AudioHandle)render, &frames, &time); -- Gitee From 7c75e2f9ffdcbdd41b8c4c794ac25f70b2e926f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 8 Aug 2024 02:28:31 +0000 Subject: [PATCH 0097/1485] update audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index dccbfc6a85..ffcefa57f0 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -230,7 +230,11 @@ int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, pthread_mutex_lock(&g_managerMutex); priv->vdiDescs = (struct AudioAdapterDescriptorVdi *)OsalMemCalloc( sizeof(struct AudioAdapterDescriptorVdi) * (*descsLen)); - CHECK_NULL_PTR_RETURN_VALUE(priv->vdiDescs, HDF_ERR_NOT_SUPPORT); + if (priv->vdiDescs == NULL) { + AUDIO_FUNC_LOGE("null point"); + pthread_mutex_unlock(&g_managerMutex); + return HDF_ERR_NOT_SUPPORT; + } priv->vdiDescsCount = *descsLen; ret = priv->vdiManager->GetAllAdapters(priv->vdiManager, priv->vdiDescs, &priv->vdiDescsCount); -- Gitee From 1ad1bad0fc3f064e634f8c03e4e22e1ec3590615 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 8 Aug 2024 02:33:25 +0000 Subject: [PATCH 0098/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index d3f8e96046..fd7e7cca2b 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -255,8 +255,11 @@ int32_t AudioDestroyCaptureVdi(struct IAudioAdapter *adapter, uint32_t captureId pthread_mutex_lock(&g_adapterMutex); struct IAudioCaptureVdi *vdiCapture = AudioGetVdiCaptureByIdVdi(captureId); - CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyCapture, HDF_ERR_INVALID_PARAM); + if (vdiCapture == NULL || vdiAdapter->DestroyCapture == NULL) { + AUDIO_FUNC_LOGE("invalid parameter"); + pthread_mutex_unlock(&g_adapterMutex); + return HDF_ERR_INVALID_PARAM; + } int32_t ret = vdiAdapter->DestroyCapture(vdiAdapter, vdiCapture); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio vdiAdapter call DestroyCapture fail, ret=%{public}d", ret); -- Gitee From 839db96b73e417c0bffdb53180da139ef75ceced Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Thu, 8 Aug 2024 10:42:10 +0800 Subject: [PATCH 0099/1485] add codec HDI fuzz Signed-off-by: suxiaosu007 --- .../codecallocatebuffer_fuzzer.cpp | 11 ++++-- .../codeccommon_fuzzer.cpp | 13 ++++--- .../codechdi_fuzzer/codec_fuzzer.cpp | 5 +++ .../imageallocateinbuffer_fuzzer.cpp | 6 ++++ .../imagedojpegdecode_fuzzer.cpp | 6 ++++ .../imagefreeinbuffer_fuzzer.cpp | 6 ++++ .../imagegetcapability_fuzzer.cpp | 6 ++++ .../codeccommon_fuzzer.cpp | 36 +++++++++++++++++-- ...codecgetcomponentcapabilitylist_fuzzer.cpp | 5 +++ .../codecomx_fuzzer/codec_fuzzer.cpp | 5 +++ 10 files changed, 90 insertions(+), 9 deletions(-) diff --git a/codec/test/fuzztest/hdi_fuzzer/codecallocatebufferhdi_fuzzer/codecallocatebuffer_fuzzer.cpp b/codec/test/fuzztest/hdi_fuzzer/codecallocatebufferhdi_fuzzer/codecallocatebuffer_fuzzer.cpp index a490250b83..7a13661dde 100644 --- a/codec/test/fuzztest/hdi_fuzzer/codecallocatebufferhdi_fuzzer/codecallocatebuffer_fuzzer.cpp +++ b/codec/test/fuzztest/hdi_fuzzer/codecallocatebufferhdi_fuzzer/codecallocatebuffer_fuzzer.cpp @@ -18,6 +18,9 @@ namespace OHOS { namespace Codec { + + static const uint32_t OMX_MAX_PORT_INDEX = 2; + bool CodecAllocateBuffer(const uint8_t *data, size_t size) { if (data == nullptr) { @@ -32,8 +35,12 @@ namespace Codec { struct OmxCodecBuffer inbuffer, outBuffer; FillDataOmxCodecBuffer(&inbuffer); - - int32_t ret = g_component->AllocateBuffer(static_cast(*(const_cast(data))), + int32_t ret = g_component->SendCommand(HDI::Codec::V3_0::CODEC_COMMAND_STATE_SET, + HDI::Codec::V3_0::CODEC_STATE_IDLE, {}); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Set LOADED failed, ret is [%{public}x]\n", __func__, ret); + } + ret = g_component->AllocateBuffer(static_cast((*(const_cast(data)) % OMX_MAX_PORT_INDEX)), inbuffer, outBuffer); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: AllocateBuffer failed, ret is [%{public}x]\n", __func__, ret); diff --git a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp index 06d4b96b9d..c5027e5e7c 100644 --- a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp +++ b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp @@ -14,15 +14,20 @@ */ #include "codeccommon_fuzzer.h" +#include using namespace OHOS::HDI::Codec::V3_0; +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { static const int32_t DATA_BUFFERID = 10; static const int32_t DATA_SIZE = 20; static const int32_t DATA_VERSION_NVERSION = 30; - static const int32_t DATA_BUFFERTYPE = 40; static const int32_t DATA_ALLOCLEN = 60; static const int32_t DATA_FILLEDLEN = 70; static const int32_t DATA_OFFSET = 80; @@ -47,7 +52,7 @@ namespace Codec { dataFuzz->bufferId = DATA_BUFFERID; dataFuzz->size = DATA_SIZE; dataFuzz->version.nVersion = DATA_VERSION_NVERSION; - dataFuzz->bufferType = static_cast(DATA_BUFFERTYPE); + dataFuzz->bufferType = CODEC_BUFFER_TYPE_DMA_MEM_FD; dataFuzz->bufferhandle = nullptr; dataFuzz->fd = -1; dataFuzz->allocLen = DATA_ALLOCLEN; @@ -79,7 +84,7 @@ namespace Codec { if (err != HDF_SUCCESS || count <= 0) { HDF_LOGE("%{public}s GetComponentNum return %{public}d, count = %{public}d", __func__, err, count); Release(); - return false; + return HDF_FAILURE; } std::vector caps; @@ -87,7 +92,7 @@ namespace Codec { if (err != HDF_SUCCESS) { HDF_LOGE("%{public}s GetComponentCapabilityList return %{public}d", __func__, err); Release(); - return false; + return err; } int32_t ret = g_manager->CreateComponent(g_component, g_componentId, caps[0].compName, g_appData, g_callback); diff --git a/codec/test/fuzztest/hdi_fuzzer/codechdi_fuzzer/codec_fuzzer.cpp b/codec/test/fuzztest/hdi_fuzzer/codechdi_fuzzer/codec_fuzzer.cpp index d1fe82917d..28e5c7ce74 100644 --- a/codec/test/fuzztest/hdi_fuzzer/codechdi_fuzzer/codec_fuzzer.cpp +++ b/codec/test/fuzztest/hdi_fuzzer/codechdi_fuzzer/codec_fuzzer.cpp @@ -21,6 +21,11 @@ using namespace OHOS::HDI::Codec::V3_0; +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { constexpr size_t THRESHOLD = 10; constexpr int32_t OFFSET = 4; diff --git a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp index e192bf224a..86f9d20839 100644 --- a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp @@ -21,6 +21,12 @@ using namespace OHOS::HDI::Codec::Image::V1_0; using namespace OHOS; using namespace std; + +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { namespace Image { diff --git a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp index dd1df861f7..98d8857343 100644 --- a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp @@ -23,6 +23,12 @@ using namespace OHOS::HDI::Codec::Image::V1_0; using namespace OHOS; using namespace std; + +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { namespace Image { diff --git a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp index 96cc9ac824..721cfb5a86 100644 --- a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp @@ -22,6 +22,12 @@ using namespace OHOS::HDI::Codec::Image::V1_0; using namespace OHOS; using namespace std; + +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { namespace Image { diff --git a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp index 81d7d1d140..67b40c09c3 100644 --- a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp @@ -20,6 +20,12 @@ using namespace OHOS::HDI::Codec::Image::V1_0; using namespace OHOS; using namespace std; + +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { namespace Image { diff --git a/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp b/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp index 499c944226..e419f55fa4 100644 --- a/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp +++ b/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp @@ -15,6 +15,13 @@ #include "codeccommon_fuzzer.h" #include "codec_omx_ext.h" +#include + +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { static const int32_t DATA_BUFFERID = 10; @@ -84,14 +91,37 @@ namespace Codec { return false; } - std::string compName("OMX.rk.video_encoder.avc"); - int32_t ret = g_manager->CreateComponent(&g_component, &g_componentId, compName.data(), g_appData, g_callback); + int32_t count = g_manager->GetComponentNum(); + if (count <= 0) { + CodecCallbackTypeRelease(g_callback); + HDF_LOGE("%{public}s GetComponentNum count = %{public}d", __func__, count); + return false; + } + + CodecCompCapability *capList = reinterpret_cast(OsalMemAlloc(sizeof(CodecCompCapability) + * count)); + if (capList == nullptr) { + CodecCallbackTypeRelease(g_callback); + HDF_LOGE("%{public}s: OsalMemAlloc CodecCompCapability failed\n", __func__); + return false; + } + + int32_t ret = g_manager->GetComponentCapabilityList(capList, count); if (ret != HDF_SUCCESS) { + OsalMemFree(capList); CodecCallbackTypeRelease(g_callback); - HDF_LOGE("%{public}s: CreateComponent failed\n", __func__); + HDF_LOGI("%{public}s: GetComponentCapabilityList succeed\n", __func__); return false; } + ret = g_manager->CreateComponent(&g_component, &g_componentId, capList[0].compName, g_appData, g_callback); + if (ret != HDF_SUCCESS) { + OsalMemFree(capList); + CodecCallbackTypeRelease(g_callback); + HDF_LOGE("%{public}s: CreateComponent failed\n", __func__); + return false; + } + OsalMemFree(capList); return true; } diff --git a/codec/test/fuzztest/omx_fuzzer/codecgetcomponentcapabilitylistomx_fuzzer/codecgetcomponentcapabilitylist_fuzzer.cpp b/codec/test/fuzztest/omx_fuzzer/codecgetcomponentcapabilitylistomx_fuzzer/codecgetcomponentcapabilitylist_fuzzer.cpp index 99f14ce1fd..a257b6b50a 100644 --- a/codec/test/fuzztest/omx_fuzzer/codecgetcomponentcapabilitylistomx_fuzzer/codecgetcomponentcapabilitylist_fuzzer.cpp +++ b/codec/test/fuzztest/omx_fuzzer/codecgetcomponentcapabilitylistomx_fuzzer/codecgetcomponentcapabilitylist_fuzzer.cpp @@ -21,6 +21,11 @@ #include #include +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { namespace Codec { bool CodecGetComponentCapabilityList(const uint8_t* data, size_t size) diff --git a/codec/test/fuzztest/omx_fuzzer/codecomx_fuzzer/codec_fuzzer.cpp b/codec/test/fuzztest/omx_fuzzer/codecomx_fuzzer/codec_fuzzer.cpp index 3db7667a96..19b12d4404 100644 --- a/codec/test/fuzztest/omx_fuzzer/codecomx_fuzzer/codec_fuzzer.cpp +++ b/codec/test/fuzztest/omx_fuzzer/codecomx_fuzzer/codec_fuzzer.cpp @@ -22,6 +22,11 @@ using namespace OHOS; +extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) +{ + return 0; +} + namespace OHOS { constexpr size_t THRESHOLD = 10; constexpr uint32_t OFFSET = 4; -- Gitee From 2a2c5ff94e2a60018e0902abcdf9f9e158bcebd7 Mon Sep 17 00:00:00 2001 From: Sxs Date: Thu, 8 Aug 2024 02:57:02 +0000 Subject: [PATCH 0100/1485] update codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp. Signed-off-by: Sxs --- .../hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp index c5027e5e7c..1add32bc42 100644 --- a/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp +++ b/codec/test/fuzztest/hdi_fuzzer/codeccommonhdi_fuzzer/codeccommon_fuzzer.cpp @@ -84,7 +84,7 @@ namespace Codec { if (err != HDF_SUCCESS || count <= 0) { HDF_LOGE("%{public}s GetComponentNum return %{public}d, count = %{public}d", __func__, err, count); Release(); - return HDF_FAILURE; + return false; } std::vector caps; @@ -92,7 +92,7 @@ namespace Codec { if (err != HDF_SUCCESS) { HDF_LOGE("%{public}s GetComponentCapabilityList return %{public}d", __func__, err); Release(); - return err; + return false; } int32_t ret = g_manager->CreateComponent(g_component, g_componentId, caps[0].compName, g_appData, g_callback); -- Gitee From 96905faad045b862391f1a0fc92382d95e58bfe6 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Thu, 8 Aug 2024 11:21:35 +0800 Subject: [PATCH 0101/1485] commit msg Signed-off-by: xuxuehai --- audio/audio.gni | 6 +++ audio/bundle.json | 6 ++- audio/hdi_service/primary_impl/BUILD.gn | 7 +++- .../primary_impl/vdi_src/audio_adapter_vdi.c | 42 +++++++++++++------ .../primary_impl/vdi_src/audio_capture_vdi.c | 4 +- ...{audio_trace_vdi.cpp => audio_dfx_vdi.cpp} | 29 ++++++++++++- .../{audio_trace_vdi.h => audio_dfx_vdi.h} | 9 ++-- .../primary_impl/vdi_src/audio_manager_vdi.c | 5 +++ .../primary_impl/vdi_src/audio_render_vdi.c | 6 ++- 9 files changed, 92 insertions(+), 22 deletions(-) rename audio/hdi_service/primary_impl/vdi_src/{audio_trace_vdi.cpp => audio_dfx_vdi.cpp} (55%) rename audio/hdi_service/primary_impl/vdi_src/{audio_trace_vdi.h => audio_dfx_vdi.h} (79%) diff --git a/audio/audio.gni b/audio/audio.gni index 9e4aa6ef8a..72c4e5d3a2 100644 --- a/audio/audio.gni +++ b/audio/audio.gni @@ -20,6 +20,7 @@ declare_args() { drivers_peripheral_audio_feature_double_pnp_detect = false drivers_peripheral_audio_feature_offload = false drivers_peripheral_audio_feature_multichannel = false + drivers_peripheral_audio_feature_hicollie_enable = false } if (defined(ohos_lite)) { @@ -52,3 +53,8 @@ if (defined(global_parts_info) && !defined(global_parts_info.commonlibrary_c_utils)) { enable_c_utils = false } + +if (defined(global_parts_info) && + defined(global_parts_info.hiviewdfx_hicollie)) { + drivers_peripheral_audio_feature_hicollie_enable = true +} diff --git a/audio/bundle.json b/audio/bundle.json index 6fec249e12..086eea880c 100755 --- a/audio/bundle.json +++ b/audio/bundle.json @@ -25,7 +25,8 @@ "drivers_peripheral_audio_feature_effect", "drivers_peripheral_audio_feature_double_pnp_detect", "drivers_peripheral_audio_feature_offload", - "drivers_peripheral_audio_feature_multichannel" + "drivers_peripheral_audio_feature_multichannel", + "drivers_peripheral_audio_feature_hicollie_enable" ], "adapted_system_type": ["standard", "small"], "rom": "1035KB", @@ -38,7 +39,8 @@ "hdf_core", "drivers_interface_audio", "bounds_checking_function", - "hitrace" + "hitrace", + "hicollie" ], "third_party": [ "alsa-lib" ] }, diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index 01a2e7a6b7..7c0d2d9ad0 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -44,9 +44,9 @@ ohos_shared_library("audio_primary_impl_vendor") { "vdi_src/audio_adapter_vdi.c", "vdi_src/audio_capture_vdi.c", "vdi_src/audio_common_vdi.c", + "vdi_src/audio_dfx_vdi.cpp", "vdi_src/audio_manager_vdi.c", "vdi_src/audio_render_vdi.c", - "vdi_src/audio_trace_vdi.cpp", ] include_dirs = [ @@ -85,6 +85,11 @@ ohos_shared_library("audio_primary_impl_vendor") { "hitrace:hitrace_meter", ] + if (drivers_peripheral_audio_feature_hicollie_enable) { + external_deps += [ "hicollie:libhicollie" ] + defines += [ "AUDIO_HICOLLIE_ENABLE" ] + } + install_images = [ chipset_base_dir ] subsystem_name = "hdf" part_name = "drivers_peripheral_audio" diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index d3f8e96046..56187768cf 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -23,6 +23,7 @@ #include "audio_capture_vdi.h" #include "audio_common_vdi.h" #include "audio_render_vdi.h" +#include "audio_dfx_vdi.h" #include "v4_0/iaudio_callback.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL @@ -98,14 +99,10 @@ int32_t AudioInitAllPortsVdi(struct IAudioAdapter *adapter) return HDF_SUCCESS; } -int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, - const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId) +static int32_t VerifyParamsOfAudioCreateRenderVdi(struct IAudioAdapter *adapter, + const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, + struct IAudioRender **render, uint32_t *renderId) { - AUDIO_FUNC_LOGD("enter to %{public}s", __func__); - struct AudioDeviceDescriptorVdi vdiDesc; - struct AudioSampleAttributesVdi vdiAttrs; - struct IAudioRenderVdi *vdiRender = NULL; - CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM); @@ -113,16 +110,31 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe CHECK_NULL_PTR_RETURN_VALUE(renderId, HDF_ERR_INVALID_PARAM); CHECK_VALID_RANGE_RETURN(*renderId, 0, AUDIO_VDI_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM); - struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter); - CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); - if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_OUT_HDMI || desc->pins == PIN_NONE || desc->pins >= PIN_IN_MIC) { AUDIO_FUNC_LOGE("invalid pin [%{public}d]", desc->pins); return HDF_FAILURE; } + return HDF_SUCCESS; +} + +int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, + const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId) +{ + AUDIO_FUNC_LOGD("enter to %{public}s", __func__); + struct AudioDeviceDescriptorVdi vdiDesc; + struct AudioSampleAttributesVdi vdiAttrs; + struct IAudioRenderVdi *vdiRender = NULL; + + int32_t ret = VerifyParamsOfAudioCreateRenderVdi(adapter, desc, attrs, render, renderId); + if (ret != HDF_SUCCESS) { + return ret; + } + + struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter); + CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); pthread_mutex_lock(&g_adapterMutex); *render = FindRenderCreated(desc->pins, attrs, renderId); @@ -137,7 +149,9 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe } AudioCommonAttrsToVdiAttrsVdi(attrs, &vdiAttrs); - int32_t ret = vdiAdapter->CreateRender(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiRender); + int32_t id = SetTimer("Hdi:CreateRender"); + ret = vdiAdapter->CreateRender(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiRender); + CancelTimer(id); OsalMemFree((void *)vdiDesc.desc); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio vdiAdapter call CreateRender fail, ret=%{public}d", ret); @@ -217,7 +231,9 @@ int32_t AudioCreateCaptureVdi(struct IAudioAdapter *adapter, const struct AudioD CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateCapture, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyCapture, HDF_ERR_INVALID_PARAM); pthread_mutex_lock(&g_adapterMutex); + int32_t id = SetTimer("Hdi:CreateCapture"); int32_t ret = vdiAdapter->CreateCapture(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiCapture); + CancelTimer(id); OsalMemFree((void *)vdiDesc.desc); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio vdiAdapter call CreateCapture fail, ret=%{public}d", ret); diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c index a2202c37c0..a4e09c71a2 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_capture_vdi.c @@ -21,7 +21,7 @@ #include #include "audio_uhdf_log.h" #include "audio_common_vdi.h" -#include "audio_trace_vdi.h" +#include "audio_dfx_vdi.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL @@ -72,9 +72,11 @@ int32_t AudioCaptureFrameVdi(struct IAudioCapture *capture, int8_t *frame, uint3 CHECK_NULL_PTR_RETURN_VALUE(vdiCapture, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiCapture->CaptureFrame, HDF_ERR_INVALID_PARAM); + int32_t id = SetTimer("Hdi:CaptureFrame"); HdfAudioStartTrace("Hdi:AudioCaptureFrameVdi", 0); int32_t ret = vdiCapture->CaptureFrame(vdiCapture, frame, frameLen, replyBytes); HdfAudioFinishTrace(); + CancelTimer(id); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio capture frame fail, ret=%{public}d", ret); return ret; diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.cpp b/audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.cpp similarity index 55% rename from audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.cpp rename to audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.cpp index 3369bd470a..6f04172fd5 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.cpp +++ b/audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.cpp @@ -13,8 +13,14 @@ * limitations under the License. */ -#include "audio_trace_vdi.h" +#include "audio_dfx_vdi.h" #include +#ifdef AUDIO_HICOLLIE_ENABLE +#include "xcollie/xcollie.h" +#include "xcollie/xcollie_define.h" +#endif + +#define HICOLLIE_TIMEOUT 10 void HdfAudioStartTrace(const char* value, int valueLen) { @@ -25,4 +31,25 @@ void HdfAudioStartTrace(const char* value, int valueLen) void HdfAudioFinishTrace(void) { FinishTrace(HITRACE_TAG_HDF); +} + +int32_t SetTimer(const char* name) +{ + (void)name; + int32_t id = 0; +#ifdef AUDIO_HICOLLIE_ENABLE + id = HiviewDFX::XCollie::GetInstance().SetTimer(name, HICOLLIE_TIMEOUT, nullptr, nullptr, + HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY); +#endif + return id; +} + +void CancelTimer(int32_t id) +{ + (void)id; +#ifdef AUDIO_HICOLLIE_ENABLE + if (id != 0) { + HiviewDFX::XCollie::GetInstance().CancelTimer(id); + } +#endif } \ No newline at end of file diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.h b/audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.h similarity index 79% rename from audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.h rename to audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.h index be5c87d4d0..264444359e 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_trace_vdi.h +++ b/audio/hdi_service/primary_impl/vdi_src/audio_dfx_vdi.h @@ -13,8 +13,9 @@ * limitations under the License. */ -#ifndef AUDIO_TRACE_VDI_H -#define AUDIO_TRACE_VDI_H +#ifndef AUDIO_DFX_VDI_H +#define AUDIO_DFX_VDI_H +#include "audio_types_vdi.h" #ifdef __cplusplus extern "C" { @@ -22,8 +23,10 @@ extern "C" { void HdfAudioStartTrace(const char* value, int valueLen); void HdfAudioFinishTrace(void); +int32_t SetTimer(const char* name); +void CancelTimer(int32_t id); #ifdef __cplusplus } #endif -#endif /* AUDIO_TRACE_VDI_H */ \ No newline at end of file +#endif /* AUDIO_DFX_VDI_H */ \ No newline at end of file diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index dccbfc6a85..6ff615f3a6 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -20,6 +20,7 @@ #include #include "audio_uhdf_log.h" #include "audio_adapter_vdi.h" +#include "audio_dfx_vdi.h" #include "v4_0/iaudio_adapter.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL @@ -233,7 +234,9 @@ int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, CHECK_NULL_PTR_RETURN_VALUE(priv->vdiDescs, HDF_ERR_NOT_SUPPORT); priv->vdiDescsCount = *descsLen; + int32_t id = SetTimer("Hdi:GetAllAdapters"); ret = priv->vdiManager->GetAllAdapters(priv->vdiManager, priv->vdiDescs, &priv->vdiDescsCount); + CancelTimer(id); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio vdiManager call GetAllAdapters fail, ret=%{public}d", ret); free(priv->vdiDescs); @@ -354,9 +357,11 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc pthread_mutex_lock(&g_managerMutex); struct IAudioAdapterVdi *vdiAdapter = NULL; + int32_t id = SetTimer("Hdi:LoadAdapter"); HdfAudioStartTrace("Hdi:AudioManagerVendorLoadAdapter", 0); ret = priv->vdiManager->LoadAdapter(priv->vdiManager, &vdiDesc, &vdiAdapter); HdfAudioFinishTrace(); + CancelTimer(id); AudioManagerReleaseVdiDesc(&vdiDesc); if (ret != HDF_SUCCESS) { diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 40b817b1ed..ccde8a0d67 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -21,7 +21,7 @@ #include "osal_mem.h" #include "securec.h" #include "audio_common_vdi.h" -#include "audio_trace_vdi.h" +#include "audio_dfx_vdi.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL @@ -91,9 +91,11 @@ int32_t AudioRenderFrameVdi(struct IAudioRender *render, const int8_t *frame, ui CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiRender->RenderFrame, HDF_ERR_INVALID_PARAM); + int32_t id = SetTimer("Hdi:RenderFrame"); HdfAudioStartTrace("Hdi:AudioRenderFrameVdi", 0); int32_t ret = vdiRender->RenderFrame(vdiRender, frame, frameLen, replyBytes); HdfAudioFinishTrace(); + CancelTimer(id); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio render frame fail, ret=%{public}d", ret); return ret; @@ -113,7 +115,9 @@ int32_t AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM); + int32_t id = SetTimer("Hdi:GetRenderPosition"); int32_t ret = vdiRender->GetRenderPosition(vdiRender, frames, (struct AudioTimeStampVdi *)time); + CancelTimer(id); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio render, get position fail, ret=%{public}d", ret); return ret; -- Gitee From 6d01cf7ee1c57039b4d8ee5345fa1e81eda9cbbd Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Thu, 8 Aug 2024 14:57:42 +0800 Subject: [PATCH 0102/1485] commit msg Signed-off-by: xuxuehai --- audio/bundle.json | 11 +++++++++++ audio/hdi_service/primary_impl/BUILD.gn | 5 +++++ 2 files changed, 16 insertions(+) diff --git a/audio/bundle.json b/audio/bundle.json index 6fec249e12..b180f6e699 100755 --- a/audio/bundle.json +++ b/audio/bundle.json @@ -47,6 +47,17 @@ "//drivers/peripheral/audio:hdi_audio", "//drivers/peripheral/audio/effect:effect_model" ], + "inner_kits": [ + { + "type": "so", + "name": "//drivers/peripheral/audio/hdi_service/primary_impl:audio_primary_impl_vendor", + "header": { + "header_base": "//drivers/peripheral/audio/interfaces/sound", + "header_files": [ + ] + } + } + ], "test": [ "//drivers/peripheral/audio/test:audio_test_entry", "//drivers/peripheral/audio/test/sample:idl_audio_sample", diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index 01a2e7a6b7..0d4aabe6ff 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -16,6 +16,10 @@ hdf_hdi_service_path = "./.." import("//build/ohos.gni") import("$hdf_audio_path/audio.gni") +config("drivers_peripheral_audio_header") { + include_dirs = [ "//drivers/peripheral/audio/interfaces/sound" ] +} + ohos_shared_library("audio_primary_impl_vendor") { defines = [] if (drivers_peripheral_audio_feature_community) { @@ -85,6 +89,7 @@ ohos_shared_library("audio_primary_impl_vendor") { "hitrace:hitrace_meter", ] + public_configs = [ ":drivers_peripheral_audio_header" ] install_images = [ chipset_base_dir ] subsystem_name = "hdf" part_name = "drivers_peripheral_audio" -- Gitee From a9c61d16ff5c262f42b39e41f1d09ed994fb579b Mon Sep 17 00:00:00 2001 From: Sxs Date: Thu, 8 Aug 2024 10:54:10 +0000 Subject: [PATCH 0103/1485] update codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp. Signed-off-by: Sxs --- .../omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp b/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp index e419f55fa4..b28214148b 100644 --- a/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp +++ b/codec/test/fuzztest/omx_fuzzer/codeccommonomx_fuzzer/codeccommon_fuzzer.cpp @@ -15,7 +15,7 @@ #include "codeccommon_fuzzer.h" #include "codec_omx_ext.h" -#include +#include extern "C" __attribute__((visibility("default"))) int dlclose(void* handle) { -- Gitee From e5e4187c6202a596d00e97afea8cc87f1cb4a394 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 8 Aug 2024 18:23:17 +0800 Subject: [PATCH 0104/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=8F=98=E9=87=8F?= =?UTF-8?q?=E7=B1=BB=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c | 2 +- wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c | 2 +- .../interfaces/hdi_service/service_common/wpa_supplicant_hal.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 143e818266..3e6d4edf84 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -275,7 +275,7 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, } conf.id = networkId; int pos = -1; - for (int i = 0; i < sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0]); ++i) { + for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { if (strcmp(g_wpaSsidFields[i].fieldName, name) == 0) { pos = i; conf.param = g_wpaSsidFields[i].field; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index bb1f482eb0..52a4289b51 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -987,7 +987,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdP2pGetChba0Freq(WifiWpaP2pInterface *thi static int CheckValidGroupConfigField(const P2pWpaGroupConfigArgv *argv) { int pos = -1; - for (int i = 0; i < sizeof(P2P_WPA_NETWORK_FIELDS) / sizeof(P2P_WPA_NETWORK_FIELDS[0]); ++i) { + for (int i = 0; i < (int)(sizeof(P2P_WPA_NETWORK_FIELDS) / sizeof(P2P_WPA_NETWORK_FIELDS[0])); ++i) { if (P2P_WPA_NETWORK_FIELDS[i].field == argv->param) { pos = i; break; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_supplicant_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_supplicant_hal.c index 2ff7a4a710..c80affdf0c 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_supplicant_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_supplicant_hal.c @@ -242,7 +242,7 @@ static int WpaCliCmdSetNetwork(WifiWpaStaInterface *this, const struct WpaSetNet return -1; } int pos = -1; - for (int i = 0; i < sizeof(g_wpaHalSsidFields) / sizeof(g_wpaHalSsidFields[0]); ++i) { + for (int i = 0; i < (int)(sizeof(g_wpaHalSsidFields) / sizeof(g_wpaHalSsidFields[0])); ++i) { if (g_wpaHalSsidFields[i].field == argv->param) { pos = i; break; -- Gitee From 91f7ff2249653abcffa41de8008a7a90f026ccc1 Mon Sep 17 00:00:00 2001 From: xiaosi Date: Thu, 8 Aug 2024 20:38:50 +0800 Subject: [PATCH 0105/1485] kill wifi process bugfix Signed-off-by: xiaosi --- .../hdi_service/service_common/wpa_common_cmd.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 143e818266..370ca62ba6 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -1081,7 +1081,7 @@ static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); } -static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self) +static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) { struct HdfWpaRemoteNode *pos = NULL; struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; @@ -1106,7 +1106,9 @@ static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self) newRemoteNode->callbackObj = self; newRemoteNode->service = self->AsObject(self); DListInsertTail(&newRemoteNode->node, head); - AddDeathRecipientForService(self); + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + AddDeathRecipientForService(self); + } return HDF_SUCCESS; } @@ -1861,7 +1863,7 @@ int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWp (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); do { HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); - ret = HdfWpaAddRemoteObj(cbFunc); + ret = HdfWpaAddRemoteObj(cbFunc, ifName); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: HdfSensorAddRemoteObj false", __func__); break; -- Gitee From 87c1db7764cb8a896d7886a8f9458ad990714725 Mon Sep 17 00:00:00 2001 From: j30052480 Date: Fri, 9 Aug 2024 15:27:57 +0800 Subject: [PATCH 0106/1485] feat: power independent compile modify Signed-off-by: j30052480 --- power/interfaces/hdi_service/BUILD.gn | 2 +- power/test/fuzztest/powerhdistub_fuzzer/BUILD.gn | 6 ++---- power/test/unittest/BUILD.gn | 3 +-- 3 files changed, 4 insertions(+), 7 deletions(-) diff --git a/power/interfaces/hdi_service/BUILD.gn b/power/interfaces/hdi_service/BUILD.gn index 02ad9d11c1..3c2bd9fddc 100644 --- a/power/interfaces/hdi_service/BUILD.gn +++ b/power/interfaces/hdi_service/BUILD.gn @@ -51,7 +51,7 @@ ohos_shared_library("libpower_interface_service_1.2") { if (drivers_peripheral_power_wakeup_cause_path) { sources += [ "src/power_config.cpp" ] - deps = [ "//third_party/jsoncpp:jsoncpp" ] + external_deps += [ "jsoncpp:jsoncpp" ] if (has_power_config_policy_part) { external_deps += [ "config_policy:configpolicy_util" ] diff --git a/power/test/fuzztest/powerhdistub_fuzzer/BUILD.gn b/power/test/fuzztest/powerhdistub_fuzzer/BUILD.gn index 6e20b8aea1..6b9891863a 100644 --- a/power/test/fuzztest/powerhdistub_fuzzer/BUILD.gn +++ b/power/test/fuzztest/powerhdistub_fuzzer/BUILD.gn @@ -29,11 +29,9 @@ ohos_fuzztest("PowerHdiStubFuzzTest") { "-fno-omit-frame-pointer", ] sources = [ "powerhdistub_fuzz.cpp" ] - deps = [ - "../../../../../interface/power/v1_2:libpower_stub_1.2", - "../../../interfaces/hdi_service:libpower_interface_service_1.2", - ] + deps = [ "../../../interfaces/hdi_service:libpower_interface_service_1.2" ] external_deps = [ + "drivers_interface_power:libpower_stub_1.2", "hdf_core:libhdf_utils", "hdf_core:libhdi", "hilog:libhilog", diff --git a/power/test/unittest/BUILD.gn b/power/test/unittest/BUILD.gn index 9fe04dc1c6..70b4e82f7b 100644 --- a/power/test/unittest/BUILD.gn +++ b/power/test/unittest/BUILD.gn @@ -37,9 +37,8 @@ ohos_unittest("hdi_unittest_power") { "-fno-strict-aliasing", ] - deps = [ "../../../../interface/power/v1_2:libpower_stub_1.2" ] - external_deps = [ + "drivers_interface_power:libpower_stub_1.2", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", -- Gitee From 6e59b8693a9ca1f8488aa167a81eac75adeec921 Mon Sep 17 00:00:00 2001 From: JillFred <14623865@qq.com> Date: Thu, 8 Aug 2024 16:14:22 +0800 Subject: [PATCH 0107/1485] add heif encode Signed-off-by: JillFred <14623865@qq.com> --- codec/image/BUILD.gn | 16 +- codec/image/config/codec_image_config.cpp | 4 +- codec/image/config/codec_image_config.h | 6 +- .../hdi_service/include/codec_image_service.h | 18 +- .../hdi_service/src/codec_image_driver.cpp | 8 +- .../hdi_service/src/codec_image_service.cpp | 16 +- .../heif/include/codec_heif_encode_service.h | 45 ++ .../heif/src/codec_heif_encode_service.cpp | 83 ++ codec/image/jpeg/include/codec_jpeg_core.h | 10 +- codec/image/jpeg/include/codec_jpeg_service.h | 10 +- codec/image/jpeg/src/codec_jpeg_core.cpp | 4 +- codec/image/jpeg/src/codec_jpeg_service.cpp | 4 +- codec/image/vdi/codec_heif_vdi.h | 41 + codec/test/BUILD.gn | 2 +- codec/test/demo/BUILD.gn | 1 + codec/test/demo/heif/BUILD.gn | 52 ++ codec/test/demo/heif/include/buffer_helper.h | 101 +++ .../demo/heif/include/codec_heif_helper.h | 63 ++ codec/test/demo/heif/include/command_parser.h | 55 ++ codec/test/demo/heif/include/log.h | 52 ++ codec/test/demo/heif/src/buffer_helper.cpp | 306 +++++++ .../test/demo/heif/src/codec_heif_helper.cpp | 349 ++++++++ codec/test/demo/heif/src/command_parser.cpp | 169 ++++ codec/test/demo/heif/src/heif_encoder.cpp | 25 + codec/test/demo/jpeg/BUILD.gn | 2 +- .../demo/jpeg/include/codec_jpeg_helper.h | 10 +- codec/test/demo/jpeg/include/jpeg_decoder.h | 12 +- .../test/demo/jpeg/src/codec_jpeg_helper.cpp | 2 +- codec/test/demo/jpeg/src/jpeg_decoder.cpp | 2 +- codec/test/fuzztest/image_fuzzer/BUILD.gn | 3 +- .../common/include/encode_buffer_helper.h | 54 ++ .../common/include/encode_heif_helper.h | 55 ++ .../common/{ => include}/image_auto_initer.h | 10 +- .../common/{ => include}/image_common.h | 4 +- .../image_fuzzer/common/include/log.h | 52 ++ .../common/src/encode_buffer_helper.cpp | 159 ++++ .../common/src/encode_heif_helper.cpp | 345 ++++++++ .../imageallocateinbuffer_fuzzer/BUILD.gn | 4 +- .../imageallocateinbuffer_fuzzer.cpp | 4 +- .../imagedoheifencode_fuzzer/BUILD.gn | 62 ++ .../imagedoheifencode_fuzzer/corpus/init | 14 + .../imagedoheifencode_fuzzer.cpp | 87 ++ .../imagedoheifencode_fuzzer.h | 22 + .../imagedoheifencode_fuzzer/project.xml | 25 + .../imagedojpegdecode_fuzzer/BUILD.gn | 4 +- .../imagedojpegdecode_fuzzer.cpp | 4 +- .../imagefreeinbuffer_fuzzer/BUILD.gn | 4 +- .../imagefreeinbuffer_fuzzer.cpp | 4 +- .../imagegetcapability_fuzzer/BUILD.gn | 2 +- .../imagegetcapability_fuzzer.cpp | 4 +- codec/test/unittest/hdi_image/BUILD.gn | 32 +- .../hdi_image/codec_hdi_heif_encode_test.cpp | 765 ++++++++++++++++++ .../hdi_image/codec_hdi_jpeg_test.cpp | 4 +- codec/test/unittest/hdi_image/test_helper.h | 86 ++ 54 files changed, 3197 insertions(+), 80 deletions(-) create mode 100644 codec/image/heif/include/codec_heif_encode_service.h create mode 100644 codec/image/heif/src/codec_heif_encode_service.cpp create mode 100644 codec/image/vdi/codec_heif_vdi.h create mode 100644 codec/test/demo/heif/BUILD.gn create mode 100644 codec/test/demo/heif/include/buffer_helper.h create mode 100644 codec/test/demo/heif/include/codec_heif_helper.h create mode 100644 codec/test/demo/heif/include/command_parser.h create mode 100644 codec/test/demo/heif/include/log.h create mode 100644 codec/test/demo/heif/src/buffer_helper.cpp create mode 100644 codec/test/demo/heif/src/codec_heif_helper.cpp create mode 100644 codec/test/demo/heif/src/command_parser.cpp create mode 100644 codec/test/demo/heif/src/heif_encoder.cpp create mode 100644 codec/test/fuzztest/image_fuzzer/common/include/encode_buffer_helper.h create mode 100644 codec/test/fuzztest/image_fuzzer/common/include/encode_heif_helper.h rename codec/test/fuzztest/image_fuzzer/common/{ => include}/image_auto_initer.h (79%) rename codec/test/fuzztest/image_fuzzer/common/{ => include}/image_common.h (93%) create mode 100644 codec/test/fuzztest/image_fuzzer/common/include/log.h create mode 100644 codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp create mode 100644 codec/test/fuzztest/image_fuzzer/common/src/encode_heif_helper.cpp create mode 100644 codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/BUILD.gn create mode 100644 codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/corpus/init create mode 100644 codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp create mode 100644 codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h create mode 100644 codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/project.xml create mode 100644 codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp create mode 100644 codec/test/unittest/hdi_image/test_helper.h diff --git a/codec/image/BUILD.gn b/codec/image/BUILD.gn index 67097cfe6a..29760f9abb 100644 --- a/codec/image/BUILD.gn +++ b/codec/image/BUILD.gn @@ -13,17 +13,19 @@ import("//build/ohos.gni") -ohos_shared_library("libcodec_image_service_1.0") { +ohos_shared_library("libcodec_image_service_2.0") { include_dirs = [ "../utils/include", "config/", - "vdi", - "jpeg/include", "hdi_service/include", + "heif/include", + "jpeg/include", + "vdi", ] sources = [ "config/codec_image_config.cpp", "hdi_service/src/codec_image_service.cpp", + "heif/src/codec_heif_encode_service.cpp", "jpeg/src/codec_jpeg_core.cpp", "jpeg/src/codec_jpeg_service.cpp", ] @@ -31,7 +33,7 @@ ohos_shared_library("libcodec_image_service_1.0") { if (is_standard_system) { external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", "hdf_core:libhdi", @@ -57,14 +59,14 @@ ohos_shared_library("libcodec_image_driver") { sources = [ "hdi_service/src/codec_image_driver.cpp" ] - deps = [ ":libcodec_image_service_1.0" ] + deps = [ ":libcodec_image_service_2.0" ] defines = [ "LOG_TAG_IMAGE" ] if (is_standard_system) { external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_stub_1.0", + "drivers_interface_codec:libimage_stub_2.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", @@ -86,6 +88,6 @@ ohos_shared_library("libcodec_image_driver") { group("codec_image_service") { deps = [ ":libcodec_image_driver", - ":libcodec_image_service_1.0", + ":libcodec_image_service_2.0", ] } diff --git a/codec/image/config/codec_image_config.cpp b/codec/image/config/codec_image_config.cpp index 5209a45bee..cbe9f88a2c 100644 --- a/codec/image/config/codec_image_config.cpp +++ b/codec/image/config/codec_image_config.cpp @@ -38,7 +38,7 @@ namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { CodecImageConfig CodecImageConfig::config_; CodecImageConfig::CodecImageConfig() @@ -177,7 +177,7 @@ int32_t CodecImageConfig::GetUintTableConfig(const struct DeviceResourceIface &i } return HDF_SUCCESS; } -} // V1_0 +} // V2_0 } // Image } // Codec } // HDI diff --git a/codec/image/config/codec_image_config.h b/codec/image/config/codec_image_config.h index 8abd4e1836..88b345042f 100644 --- a/codec/image/config/codec_image_config.h +++ b/codec/image/config/codec_image_config.h @@ -17,12 +17,12 @@ #define CODEC_IMAGE_CONFIG_H #include #include "device_resource_if.h" -#include "v1_0/codec_image_type.h" +#include "v2_0/codec_image_type.h" namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { struct ConfigUintNodeAttr { std::string attrName; uint32_t &value; @@ -55,7 +55,7 @@ private: std::vector capList_; static CodecImageConfig config_; }; -} // V1_0 +} // V2_0 } // Image } // Codec } // HDI diff --git a/codec/image/hdi_service/include/codec_image_service.h b/codec/image/hdi_service/include/codec_image_service.h index 1b51efc80c..99bbfe753f 100644 --- a/codec/image/hdi_service/include/codec_image_service.h +++ b/codec/image/hdi_service/include/codec_image_service.h @@ -13,22 +13,23 @@ * limitations under the License. */ -#ifndef OHOS_HDI_CODEC_V1_0_CODECIMAGESERVICE_H -#define OHOS_HDI_CODEC_V1_0_CODECIMAGESERVICE_H +#ifndef OHOS_HDI_CODEC_V2_0_CODECIMAGESERVICE_H +#define OHOS_HDI_CODEC_V2_0_CODECIMAGESERVICE_H #include #include #include "buffer_handle.h" #include "codec_image_config.h" -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" #include "codec_jpeg_service.h" +#include "codec_heif_encode_service.h" constexpr uint32_t CODEC_IMAGE_MAX_BUFFER_SIZE = 50 * 1024 *1024; namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { class CodecImageService : public ICodecImage { public: explicit CodecImageService(); @@ -48,13 +49,18 @@ public: int32_t FreeInBuffer(const CodecImageBuffer& buffer) override; + int32_t DoHeifEncode(const std::vector& inputImgs, const std::vector& inputMetas, + const std::vector& refs, const SharedBuffer& output, + uint32_t& filledLen) override; + private: std::unique_ptr jpegImpl_; + std::unique_ptr heifEncodeImpl_; }; -} // V1_0 +} // V2_0 } // Image } // Codec } // HDI } // OHOS -#endif // OHOS_HDI_CODEC_V1_0_CODECIMAGESERVICE_H +#endif // OHOS_HDI_CODEC_V2_0_CODECIMAGESERVICE_H diff --git a/codec/image/hdi_service/src/codec_image_driver.cpp b/codec/image/hdi_service/src/codec_image_driver.cpp index e5f87a0b93..71853089e9 100644 --- a/codec/image/hdi_service/src/codec_image_driver.cpp +++ b/codec/image/hdi_service/src/codec_image_driver.cpp @@ -19,9 +19,9 @@ #include #include "codec_image_config.h" #include "codec_log_wrapper.h" -#include "v1_0/codec_image_stub.h" +#include "v2_0/codec_image_stub.h" -using namespace OHOS::HDI::Codec::Image::V1_0; +using namespace OHOS::HDI::Codec::Image::V2_0; struct HdfCodecImageHost { struct IDeviceIoService ioService; @@ -73,7 +73,7 @@ static int HdfCodecImageDriverBind(struct HdfDeviceObject *deviceObject) hdfCodecImageHost->ioService.Open = NULL; hdfCodecImageHost->ioService.Release = NULL; - auto serviceImpl = OHOS::HDI::Codec::Image::V1_0::ICodecImage::Get(true); + auto serviceImpl = OHOS::HDI::Codec::Image::V2_0::ICodecImage::Get(true); if (serviceImpl == nullptr) { CODEC_LOGE("failed to get of implement service"); delete hdfCodecImageHost; @@ -81,7 +81,7 @@ static int HdfCodecImageDriverBind(struct HdfDeviceObject *deviceObject) } hdfCodecImageHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl, - OHOS::HDI::Codec::Image::V1_0::ICodecImage::GetDescriptor()); + OHOS::HDI::Codec::Image::V2_0::ICodecImage::GetDescriptor()); if (hdfCodecImageHost->stub == nullptr) { CODEC_LOGE("failed to get stub object"); delete hdfCodecImageHost; diff --git a/codec/image/hdi_service/src/codec_image_service.cpp b/codec/image/hdi_service/src/codec_image_service.cpp index 94c53876a7..4748c61df9 100644 --- a/codec/image/hdi_service/src/codec_image_service.cpp +++ b/codec/image/hdi_service/src/codec_image_service.cpp @@ -22,7 +22,7 @@ namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { extern "C" ICodecImage *CodecImageImplGetInstance(void) { return new (std::nothrow) CodecImageService(); @@ -31,6 +31,7 @@ extern "C" ICodecImage *CodecImageImplGetInstance(void) CodecImageService::CodecImageService() { jpegImpl_ = std::make_unique(); + heifEncodeImpl_ = std::make_unique(); } int32_t CodecImageService::GetImageCapability(std::vector& capList) @@ -105,7 +106,18 @@ int32_t CodecImageService::FreeInBuffer(const CodecImageBuffer& inBuffer) return HDF_ERR_NOT_SUPPORT; } } -} // V1_0 + +int32_t CodecImageService::DoHeifEncode(const std::vector& inputImgs, + const std::vector& inputMetas, + const std::vector& refs, + const SharedBuffer& output, uint32_t& filledLen) +{ + HITRACE_METER_NAME(HITRACE_TAG_HDF, "HdfCodecDoHeifEncode"); + CODEC_LOGI("servcie impl!"); + CHECK_AND_RETURN_RET_LOG(heifEncodeImpl_ != nullptr, HDF_FAILURE, "heifEncodeImpl_ is null"); + return heifEncodeImpl_->DoHeifEncode(inputImgs, inputMetas, refs, output, filledLen); +} +} // V2_0 } // Image } // Codec } // HDI diff --git a/codec/image/heif/include/codec_heif_encode_service.h b/codec/image/heif/include/codec_heif_encode_service.h new file mode 100644 index 0000000000..89ebf0fb34 --- /dev/null +++ b/codec/image/heif/include/codec_heif_encode_service.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_CODEC_V2_0_CODECHEIFENCODESERVICE_H +#define OHOS_HDI_CODEC_V2_0_CODECHEIFENCODESERVICE_H + +#include "codec_heif_vdi.h" +#include "v2_0/icodec_image.h" + +namespace OHOS { +namespace HDI { +namespace Codec { +namespace Image { +namespace V2_0 { +class CodecHeifEncodeService { +public: + CodecHeifEncodeService() = default; + ~CodecHeifEncodeService() = default; + int32_t DoHeifEncode(const std::vector& inputImgs, const std::vector& inputMetas, + const std::vector& refs, const SharedBuffer& output, uint32_t& filledLen); +private: + bool LoadVendorLib(); +private: + std::shared_ptr libHeif_ = nullptr; + ICodecHeifHwi* heifHwi_ = nullptr; +}; +} // V2_0 +} // Image +} // Codec +} // HDI +} // OHOS + +#endif // OHOS_HDI_CODEC_V2_0_CODECHEIFENCODESERVICE_H diff --git a/codec/image/heif/src/codec_heif_encode_service.cpp b/codec/image/heif/src/codec_heif_encode_service.cpp new file mode 100644 index 0000000000..cbab7cd116 --- /dev/null +++ b/codec/image/heif/src/codec_heif_encode_service.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "codec_heif_encode_service.h" +#include "codec_log_wrapper.h" +#include "hdf_base.h" +#include +#include + +namespace OHOS { +namespace HDI { +namespace Codec { +namespace Image { +namespace V2_0 { +using GetCodecHeifHwi = ICodecHeifHwi*(*)(); + +bool CodecHeifEncodeService::LoadVendorLib() +{ + if (heifHwi_) { + return true; + } + if (libHeif_ == nullptr) { + void *handle = dlopen(CODEC_HEIF_VDI_LIB_NAME, RTLD_LAZY); + if (handle == nullptr) { + CODEC_LOGE("failed to load vendor lib"); + return false; + } + libHeif_ = std::shared_ptr(handle, dlclose); + } + auto func = reinterpret_cast(dlsym(libHeif_.get(), "GetCodecHeifHwi")); + if (func == nullptr) { + CODEC_LOGE("failed to load symbol from vendor lib"); + return false; + } + heifHwi_ = func(); + if (heifHwi_ == nullptr) { + CODEC_LOGE("failed to create heif hardware encoder"); + return false; + } + return true; +} + +int32_t CodecHeifEncodeService::DoHeifEncode(const std::vector& inputImgs, + const std::vector& inputMetas, + const std::vector& refs, + const SharedBuffer& output, uint32_t& filledLen) +{ + if (!LoadVendorLib()) { + return HDF_FAILURE; + } + SharedBuffer outputToReturn = output; + int32_t ret = (heifHwi_->DoHeifEncode)(inputImgs, inputMetas, refs, outputToReturn); + filledLen = outputToReturn.filledLen; + auto releaseRes = [](int fd) { + if (fd > 0) { + close(fd); + } + }; + for (auto one : inputImgs) { + releaseRes(one.sharedProperties.fd); + } + for (auto one : inputMetas) { + releaseRes(one.data.fd); + } + releaseRes(output.fd); + return ret; +} +} // V2_0 +} // Image +} // Codec +} // HDI +} // OHOS \ No newline at end of file diff --git a/codec/image/jpeg/include/codec_jpeg_core.h b/codec/image/jpeg/include/codec_jpeg_core.h index 22f0f31bd7..cf0bba5213 100644 --- a/codec/image/jpeg/include/codec_jpeg_core.h +++ b/codec/image/jpeg/include/codec_jpeg_core.h @@ -13,11 +13,11 @@ * limitations under the License. */ -#ifndef OHOS_HDI_CODEC_V1_0_CODECJPEGCORE_H -#define OHOS_HDI_CODEC_V1_0_CODECJPEGCORE_H +#ifndef OHOS_HDI_CODEC_V2_0_CODECJPEGCORE_H +#define OHOS_HDI_CODEC_V2_0_CODECJPEGCORE_H #include "codec_jpeg_vdi.h" -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" namespace OHOS { namespace HDI { @@ -39,7 +39,7 @@ public: int32_t FreeInBuffer(BufferHandle *buffer); - int32_t DoDecode(BufferHandle *buffer, BufferHandle *outBuffer, const V1_0::CodecJpegDecInfo *decInfo); + int32_t DoDecode(BufferHandle *buffer, BufferHandle *outBuffer, const V2_0::CodecJpegDecInfo *decInfo); private: void AddVendorLib(); @@ -54,4 +54,4 @@ private: } // HDI } // OHOS -#endif // OHOS_HDI_CODEC_V1_0_CODECJPEGCORE_H +#endif // OHOS_HDI_CODEC_V2_0_CODECJPEGCORE_H diff --git a/codec/image/jpeg/include/codec_jpeg_service.h b/codec/image/jpeg/include/codec_jpeg_service.h index 380496f081..f87849488c 100644 --- a/codec/image/jpeg/include/codec_jpeg_service.h +++ b/codec/image/jpeg/include/codec_jpeg_service.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_HDI_CODEC_V1_0_CODECJPEGSERVICE_H -#define OHOS_HDI_CODEC_V1_0_CODECJPEGSERVICE_H +#ifndef OHOS_HDI_CODEC_V2_0_CODECJPEGSERVICE_H +#define OHOS_HDI_CODEC_V2_0_CODECJPEGSERVICE_H #include #include @@ -26,7 +26,7 @@ namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { class CodecJpegService { public: explicit CodecJpegService(); @@ -53,10 +53,10 @@ private: std::mutex initMutex_; std::unique_ptr core_; }; -} // V1_0 +} // V2_0 } // Image } // Codec } // HDI } // OHOS -#endif // OHOS_HDI_CODEC_V1_0_CODECJPEGSERVICE_H +#endif // OHOS_HDI_CODEC_V2_0_CODECJPEGSERVICE_H diff --git a/codec/image/jpeg/src/codec_jpeg_core.cpp b/codec/image/jpeg/src/codec_jpeg_core.cpp index fefdb83024..e8bb0a79d6 100644 --- a/codec/image/jpeg/src/codec_jpeg_core.cpp +++ b/codec/image/jpeg/src/codec_jpeg_core.cpp @@ -85,10 +85,10 @@ int32_t CodecJpegCore::FreeInBuffer(BufferHandle *buffer) } int32_t CodecJpegCore::DoDecode(BufferHandle *buffer, BufferHandle *outBuffer, - const V1_0::CodecJpegDecInfo *decInfo) + const V2_0::CodecJpegDecInfo *decInfo) { CHECK_AND_RETURN_RET_LOG(JpegHwi_ != nullptr, HDF_FAILURE, "JpegHwi_ is null"); - CodecJpegDecInfo *vdiDecInfo = reinterpret_cast(const_cast(decInfo)); + CodecJpegDecInfo *vdiDecInfo = reinterpret_cast(const_cast(decInfo)); return (JpegHwi_->DoJpegDecode)(buffer, outBuffer, vdiDecInfo); } } // Image diff --git a/codec/image/jpeg/src/codec_jpeg_service.cpp b/codec/image/jpeg/src/codec_jpeg_service.cpp index bdc0c9b940..59a5f154c2 100644 --- a/codec/image/jpeg/src/codec_jpeg_service.cpp +++ b/codec/image/jpeg/src/codec_jpeg_service.cpp @@ -19,7 +19,7 @@ namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { CodecJpegService::CodecJpegService() { core_ = std::make_unique(); @@ -110,7 +110,7 @@ uint32_t CodecJpegService::GetNextBufferId(void) return bufferId_; } -} // V1_0 +} // V2_0 } // Image } // Codec } // HDI diff --git a/codec/image/vdi/codec_heif_vdi.h b/codec/image/vdi/codec_heif_vdi.h new file mode 100644 index 0000000000..76a12150a6 --- /dev/null +++ b/codec/image/vdi/codec_heif_vdi.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CODEC_HEIF_VDI_H +#define CODEC_HEIF_VDI_H + +#include +#include "native_buffer.h" +#include "v2_0/codec_image_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define CODEC_HEIF_VDI_LIB_NAME "libheif_vdi_impl.z.so" + +struct ICodecHeifHwi { + int32_t (*DoHeifEncode)(const std::vector& inputImgs, + const std::vector& inputMetas, + const std::vector& refs, + OHOS::HDI::Codec::Image::V2_0::SharedBuffer& output); +}; + +struct ICodecHeifHwi *GetCodecHeifHwi(void); + +#ifdef __cplusplus +} +#endif +#endif /* CODEC_HEIF_VDI_H */ diff --git a/codec/test/BUILD.gn b/codec/test/BUILD.gn index ec47f3590c..4c0d45cc70 100644 --- a/codec/test/BUILD.gn +++ b/codec/test/BUILD.gn @@ -19,7 +19,7 @@ group("hdf_test_media_codec") { "benchmarktest:hdf_codec_idl_benchmark_test", "demo:hdf_demo_codec", "fuzztest/hdi_fuzzer:hdf_codec_idl_fuzz_test", - "fuzztest/image_fuzzer:hdf_jpeg_fuzz_test", + "fuzztest/image_fuzzer:hdf_image_fuzz_test", "fuzztest/omx_fuzzer:hdf_fuzztest_media_codec", "unittest:hdf_unittest_codec", ] diff --git a/codec/test/demo/BUILD.gn b/codec/test/demo/BUILD.gn index f51c381673..bd268337aa 100644 --- a/codec/test/demo/BUILD.gn +++ b/codec/test/demo/BUILD.gn @@ -16,6 +16,7 @@ import("../../codec.gni") group("hdf_demo_codec") { testonly = true deps = [ + "heif:codec_hdi_heif_demo", "idl:codec_idl_omx_demo", "jpeg:codec_hdi_jpeg_demo", "v2.0:codec_hdi_omx_demo", diff --git a/codec/test/demo/heif/BUILD.gn b/codec/test/demo/heif/BUILD.gn new file mode 100644 index 0000000000..3733ad6e22 --- /dev/null +++ b/codec/test/demo/heif/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (c) 2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +ohos_executable("codec_heif_encode") { + include_dirs = [ "./include" ] + + sources = [ + "src/buffer_helper.cpp", + "src/codec_heif_helper.cpp", + "src/command_parser.cpp", + "src/heif_encoder.cpp", + ] + + if (is_standard_system) { + external_deps = [ + "c_utils:utils", + "drivers_interface_codec:libimage_proxy_2.0", + "drivers_interface_display:display_buffer_idl_headers_1.2", + "drivers_interface_display:display_composer_idl_headers_1.2", + "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_2", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hilog:libhilog", + "ipc:ipc_single", + ] + } else { + external_deps = [ "hilog:libhilog" ] + } + install_enable = false + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_codec" +} + +group("codec_hdi_heif_demo") { + deps = [ ":codec_heif_encode" ] +} diff --git a/codec/test/demo/heif/include/buffer_helper.h b/codec/test/demo/heif/include/buffer_helper.h new file mode 100644 index 0000000000..593f228e2a --- /dev/null +++ b/codec/test/demo/heif/include/buffer_helper.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_CODEC_IMAGE_V2_0_BUFFER_HELPER +#define OHOS_HDI_CODEC_IMAGE_V2_0_BUFFER_HELPER + +#include +#include +#include +#include +#include +#include "log.h" +#include "v2_0/icodec_image.h" +#include "v1_2/display_composer_type.h" +#include "v1_2/display_buffer_type.h" +#include "v1_2/include/idisplay_buffer.h" + +namespace OHOS::VDI::HEIF { +class BufferHelper { +public: + BufferHelper(); + ~BufferHelper(); + OHOS::sptr CreateImgBuffer(const std::string& imageFile); + OHOS::HDI::Codec::Image::V2_0::SharedBuffer CreateSharedBuffer( + std::map& metaInfo); + OHOS::HDI::Codec::Image::V2_0::SharedBuffer CreateSharedBuffer(const std::string& metaFile); + void DumpBuffer(const std::string& filePath, const OHOS::HDI::Codec::Image::V2_0::SharedBuffer& buffer); +private: + struct PixelFileInfo { + uint32_t displayWidth; + uint32_t alignedWidth; + uint32_t displayHeight; + uint32_t alignedHeight; + uint32_t pixFmt; + }; +private: + static bool ExtractPixelInfoFromFilePath(const std::string& filePath, PixelFileInfo& pixelInfo); + static uint32_t GetPixelFmtFromFileSuffix(const std::string& imageFile); + bool CopyYuvData(BufferHandle *handle, std::ifstream &ifs, PixelFileInfo& pixelInfo); + bool CopyRgbaData(BufferHandle *handle, std::ifstream &ifs, PixelFileInfo& pixelInfo); +private: + OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer* bufferMgr_; + std::set allocatedFd_; +}; + +class ByteWriter { +public: + ByteWriter() = default; + ~ByteWriter(); + template + bool AddData(OHOS::HDI::Codec::Image::V2_0::PropertyType key, T& value) + { + std::size_t keySize = sizeof(key); + std::size_t valueSize = sizeof(value); + std::size_t dataSize = keySize + valueSize; + uint8_t* p = new uint8_t[dataSize]; + IF_TRUE_RETURN_VAL(p == nullptr, false); + data_.emplace_back(DataBlock { + .data = p, + .len = dataSize + }); + totalSize_ += dataSize; + HDF_LOGD("key=%{public}d, keySize=%{public}zu, valueSize=%{public}zu, " \ + "dataSize=%{public}zu, totalSize_=%{public}zu", + key, keySize, valueSize, dataSize, totalSize_); + errno_t ret = memset_s(p, dataSize, 0, dataSize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + ret = memcpy_s(p, dataSize, reinterpret_cast(&key), keySize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + ret = memcpy_s(p + keySize, valueSize, reinterpret_cast(&value), valueSize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + return true; + } + bool Finalize(std::vector& dst); + bool AddDataFromFile(OHOS::HDI::Codec::Image::V2_0::PropertyType key, const std::string& filePath); + bool Finalize(OHOS::HDI::Codec::Image::V2_0::SharedBuffer& buffer); +private: + struct DataBlock { + uint8_t* data = nullptr; + std::size_t len = 0; + }; +private: + bool CopyDataTo(uint8_t* dstStart); +private: + std::list data_; + std::size_t totalSize_ = 0; +}; +} // OHOS::VDI::HEIF +#endif // OHOS_HDI_CODEC_IMAGE_V2_0_BUFFER_HELPER \ No newline at end of file diff --git a/codec/test/demo/heif/include/codec_heif_helper.h b/codec/test/demo/heif/include/codec_heif_helper.h new file mode 100644 index 0000000000..d9d115fdd8 --- /dev/null +++ b/codec/test/demo/heif/include/codec_heif_helper.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_CODEC_IMAGE_V2_0_CODEC_HEIF_HELPER +#define OHOS_HDI_CODEC_IMAGE_V2_0_CODEC_HEIF_HELPER + +#include +#include "command_parser.h" +#include "buffer_helper.h" + +namespace OHOS::VDI::HEIF { +class HeifEncoderHelper { +public: + explicit HeifEncoderHelper(const CommandOpt& opt) : encodeOpt_(opt) {} + ~HeifEncoderHelper() = default; + void DoEncode(); +private: + enum ImgType { + PRIMARY_IMG, + AUXILIARY_IMG, + THUMBNAIL_IMG, + GAIN_MAP, + T_MAP + }; + enum MetaType { + EXIF_DATA, + USER_DATA + }; +private: + void Reset(); + bool AssembleParamForTmap(); + bool AssembleParamForPrimaryImg(); + bool AssembleParamForOtherImg(uint32_t primaryImgId); + bool AssembleParamForMetaData(uint32_t primaryImgId); + uint32_t GetNextId() { return id_++; } + bool FillImageItem(ImgType type, OHOS::HDI::Codec::Image::V2_0::ImageItem& item); + bool FillMetaItem(const std::string& metaFile, MetaType type, OHOS::HDI::Codec::Image::V2_0::MetaItem& item); + static bool AddPropOnlyForTmap(ByteWriter& bw); + bool AddPropMirrorAndRotate(ByteWriter& bw); + bool CreateImgParam(ImgType type, std::vector& props); + bool AllocOutputBuffer(OHOS::HDI::Codec::Image::V2_0::SharedBuffer& output); +private: + CommandOpt encodeOpt_; + std::vector inputImgs_; + std::vector inputMetas_; + std::vector refs_; + uint32_t id_ = 0; + BufferHelper bufferHelper_; +}; +} // OHOS::VDI::HEIF +#endif // OHOS_HDI_CODEC_IMAGE_V2_0_CODEC_HEIF_HELPER \ No newline at end of file diff --git a/codec/test/demo/heif/include/command_parser.h b/codec/test/demo/heif/include/command_parser.h new file mode 100644 index 0000000000..e0543e1615 --- /dev/null +++ b/codec/test/demo/heif/include/command_parser.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_CODEC_IMAGE_V2_0_COMMAND_PARSER +#define OHOS_HDI_CODEC_IMAGE_V2_0_COMMAND_PARSER + +#include +#include + +namespace OHOS::VDI::HEIF { +enum ImageMirror { + HORIZONTAL, + VERTICAL, + NONE +}; + +enum class ImageRotation { + ANTI_CLOCKWISE_90, + ANTI_CLOCKWISE_180, + ANTI_CLOCKWISE_270, + NONE +}; + +struct CommandOpt { + std::string primaryImgPath = ""; + std::string auxiliaryImgPath = ""; + std::string thumbnailImgPath = ""; + std::string gainMapPath = ""; + std::string exifDataPath = ""; + std::string userDataPath = ""; + std::string iccProfilePath = ""; + std::string it35Path = ""; + std::string outputPath = "/storage/media/100/local/files/heif_edit_dump"; + ImageMirror mirrorInfo = ImageMirror::NONE; + ImageRotation rotateInfo = ImageRotation::NONE; + + void Print() const; +}; + +CommandOpt Parse(int argc, char *argv[]); +void ShowUsage(); +} // OHOS::VDI::HEIF +#endif // OHOS_HDI_CODEC_IMAGE_V2_0_COMMAND_PARSER \ No newline at end of file diff --git a/codec/test/demo/heif/include/log.h b/codec/test/demo/heif/include/log.h new file mode 100644 index 0000000000..3b016c7afd --- /dev/null +++ b/codec/test/demo/heif/include/log.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ENCODE_HEIF_LOG +#define ENCODE_HEIF_LOG + +#include "hdf_log.h" +#define HDF_LOG_TAG codec_heif_encoder + +#define IF_TRUE_RETURN(cond) \ + do { \ + if (cond) { \ + return; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_WITH_MSG(cond, msg, ...) \ + do { \ + if (cond) { \ + HDF_LOGE(msg, ##__VA_ARGS__); \ + return; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_VAL(cond, val) \ + do { \ + if (cond) { \ + return val; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_VAL_WITH_MSG(cond, val, msg, ...) \ + do { \ + if (cond) { \ + HDF_LOGE(msg, ##__VA_ARGS__); \ + return val; \ + } \ + } while (0) + +#endif // ENCODE_HEIF_LOG \ No newline at end of file diff --git a/codec/test/demo/heif/src/buffer_helper.cpp b/codec/test/demo/heif/src/buffer_helper.cpp new file mode 100644 index 0000000000..3b0f314570 --- /dev/null +++ b/codec/test/demo/heif/src/buffer_helper.cpp @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "ashmem.h" +#include "buffer_helper.h" + +namespace OHOS::VDI::HEIF { +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace OHOS::HDI::Display::Buffer::V1_2; +using namespace OHOS::HDI::Display::Composer::V1_2; +using namespace std; + +static size_t GetFileSizeInBytes(ifstream &ifs) +{ + ifs.seekg(0, ifstream::end); + auto len = ifs.tellg(); + ifs.seekg(0, ifstream::beg); + return static_cast(len); +} + +BufferHelper::BufferHelper() +{ + bufferMgr_ = OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer::Get(); +} + +BufferHelper::~BufferHelper() +{ + bufferMgr_ = nullptr; + for (auto iter = allocatedFd_.begin(); iter != allocatedFd_.end(); ++iter) { + close(*iter); + } + allocatedFd_.clear(); +} + +bool BufferHelper::ExtractPixelInfoFromFilePath(const string& filePath, PixelFileInfo& pixelInfo) +{ + size_t pos = filePath.find_last_of('/'); + IF_TRUE_RETURN_VAL(pos == string::npos, false); + pos = filePath.find_first_of('[', pos); + IF_TRUE_RETURN_VAL(pos == string::npos, false); + int ret = sscanf_s(filePath.substr(pos).c_str(), "[%ux%u][%ux%u][fmt0x%x].yuv", + &pixelInfo.displayWidth, &pixelInfo.displayHeight, + &pixelInfo.alignedWidth, &pixelInfo.alignedHeight, + &pixelInfo.pixFmt); + static constexpr int EXP_CNT = 5; + IF_TRUE_RETURN_VAL(ret != EXP_CNT, false); + HDF_LOGI("pixel info: display=[%{public}u x %{public}u], aligned=[%{public}u x %{public}u]", + pixelInfo.displayWidth, pixelInfo.displayHeight, pixelInfo.alignedWidth, pixelInfo.alignedHeight); + return true; +} + +bool BufferHelper::CopyYuvData(BufferHandle *handle, ifstream &ifs, PixelFileInfo& pixelInfo) +{ + static constexpr uint32_t BYTES_PER_PIXEL_YUV = 1; + // Y plane + char* dst = reinterpret_cast(handle->virAddr); + for (uint32_t i = 0; i < pixelInfo.displayHeight; i++) { + ifs.read(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_YUV); + dst += handle->stride; + } + // skip aligned lines + for (uint32_t i = 0; i < (pixelInfo.alignedHeight - pixelInfo.displayHeight); i++) { + ifs.read(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_YUV); + } + // UV plane + ImageLayout layout; + int32_t ret = bufferMgr_->GetImageLayout(*handle, layout); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != HDF_SUCCESS, false, + "failed to get uv start, err [%{public}d] !", ret); + static constexpr int PLANE_U = 1; + static constexpr int PLANE_V = 2; + static constexpr uint32_t UV_SAMPLE_RATE = 2; + uint64_t uvOffset = (pixelInfo.pixFmt == OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YCBCR_420_SP) ? + layout.planes[PLANE_U].offset : + layout.planes[PLANE_V].offset; + dst = reinterpret_cast(handle->virAddr) + uvOffset; + for (uint32_t i = 0; i < pixelInfo.displayHeight / UV_SAMPLE_RATE; i++) { + ifs.read(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_YUV); + dst += handle->stride; + } + return true; +} + +bool BufferHelper::CopyRgbaData(BufferHandle *handle, ifstream &ifs, PixelFileInfo& pixelInfo) +{ + static constexpr uint32_t BYTES_PER_PIXEL_RBGA = 4; + char* dst = reinterpret_cast(handle->virAddr); + for (uint32_t i = 0; i < pixelInfo.displayHeight; i++) { + ifs.read(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA); + dst += handle->stride; + } + return true; +} + +uint32_t BufferHelper::GetPixelFmtFromFileSuffix(const string& imageFile) +{ + if (imageFile.rfind(".rgba") != string::npos) { + return OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_RGBA_8888; + } + if (imageFile.rfind(".nv21") != string::npos) { + return OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YCRCB_420_SP; + } + return OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YCBCR_420_SP; +} + +sptr BufferHelper::CreateImgBuffer(const string& imageFile) +{ + IF_TRUE_RETURN_VAL(imageFile.length() <= 0, nullptr); + ifstream ifs(imageFile, ios::binary); + IF_TRUE_RETURN_VAL_WITH_MSG(!ifs.is_open(), nullptr, "cannot open %{public}s", imageFile.c_str()); + PixelFileInfo pixelInfo; + IF_TRUE_RETURN_VAL_WITH_MSG(!ExtractPixelInfoFromFilePath(imageFile, pixelInfo), nullptr, + "invalid file path format: %{public}s", imageFile.c_str()); + uint64_t usage = OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_READ | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_WRITE | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_MEM_DMA; + pixelInfo.pixFmt = GetPixelFmtFromFileSuffix(imageFile); + HDF_LOGI("pixelFmt=0x%{public}x", pixelInfo.pixFmt); + AllocInfo alloc = { + .width = pixelInfo.displayWidth, + .height = pixelInfo.displayHeight, + .usage = usage, + .format = pixelInfo.pixFmt + }; + BufferHandle *handle = nullptr; + int32_t ret = bufferMgr_->AllocMem(alloc, handle); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != HDF_SUCCESS, nullptr, + "failed to alloc buffer, err [%{public}d] !", ret); + bufferMgr_->Mmap(*handle); + bool flag = (pixelInfo.pixFmt == OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_RGBA_8888) ? + CopyRgbaData(handle, ifs, pixelInfo) : + CopyYuvData(handle, ifs, pixelInfo); + (void)bufferMgr_->Unmap(*handle); + if (!flag) { + bufferMgr_->FreeMem(*handle); + return nullptr; + } + sptr imgBuffer = new NativeBuffer(handle); + return imgBuffer; +} + +SharedBuffer BufferHelper::CreateSharedBuffer(map& metaInfo) +{ + SharedBuffer buffer = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + ByteWriter bw; + bool flag = true; + for (auto iter = metaInfo.begin(); (iter != metaInfo.end()) && flag; ++iter) { + flag = bw.AddDataFromFile(iter->first, iter->second); + } + if (flag && bw.Finalize(buffer)) { + allocatedFd_.insert(buffer.fd); + } + return buffer; +} + +SharedBuffer BufferHelper::CreateSharedBuffer(const string& metaFile) +{ + SharedBuffer buffer = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + IF_TRUE_RETURN_VAL_WITH_MSG(metaFile.length() <= 0, buffer, "no metaFile"); + ifstream ifs(metaFile, ios::binary); + IF_TRUE_RETURN_VAL_WITH_MSG(!ifs.is_open(), buffer, "cannot open %{public}s", metaFile.c_str()); + size_t totalSize = GetFileSizeInBytes(ifs); + int fd = AshmemCreate("ForMetaData", totalSize); + IF_TRUE_RETURN_VAL_WITH_MSG(fd < 0, buffer, "cannot create ashmem for meta data"); + void *addr = mmap(nullptr, totalSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (addr == nullptr) { + HDF_LOGE("failed to map addr for meta buffer"); + close(fd); + return buffer; + } + ifs.read(reinterpret_cast(addr), totalSize); + if (munmap(addr, totalSize) != 0) { + HDF_LOGW("failed to unmap addr for meta buffer"); + } + buffer.fd = fd; + buffer.filledLen = static_cast(totalSize); + buffer.capacity = static_cast(AshmemGetSize(fd)); + allocatedFd_.insert(fd); + return buffer; +} + +void BufferHelper::DumpBuffer(const string& filePath, const SharedBuffer& buffer) +{ + IF_TRUE_RETURN_WITH_MSG(filePath.length() <= 0, "dump path is empty"); + constexpr int maxPathLen = 256; + char outputFilePath[maxPathLen] = {0}; + int ret = sprintf_s(outputFilePath, sizeof(outputFilePath), "%s/out.heic", + filePath.c_str()); + if (ret == -1) { + HDF_LOGE("failed to create dump file"); + return; + } + HDF_LOGI("dump buffer to: %{public}s", outputFilePath); + ofstream ofs(outputFilePath, ios::binary); + IF_TRUE_RETURN_WITH_MSG(!ofs.is_open(), "cannot open %{public}s", outputFilePath); + void *addr = mmap(nullptr, buffer.filledLen, PROT_READ | PROT_WRITE, MAP_SHARED, buffer.fd, 0); + if (addr != nullptr) { + ofs.write(static_cast(addr), static_cast(buffer.filledLen)); + ofs.close(); + } else { + HDF_LOGE("failed to map addr for dump buffer"); + } + if (munmap(addr, buffer.filledLen) != 0) { + HDF_LOGW("failed to unmap addr for dump buffer"); + } +} + +ByteWriter::~ByteWriter() +{ + for (auto iter = data_.begin(); iter != data_.end(); ++iter) { + delete [] iter->data; + } + data_.clear(); +} + +bool ByteWriter::CopyDataTo(uint8_t* dstStart) +{ + size_t offset = 0; + errno_t ret = EOK; + for (auto iter = data_.begin(); (iter != data_.end()) && (ret == EOK); ++iter) { + ret = memcpy_s(dstStart + offset, iter->len, iter->data, iter->len); + offset += iter->len; + } + return (ret == EOK); +} + +bool ByteWriter::Finalize(std::vector& dst) +{ + dst.clear(); + dst.resize(totalSize_); + return CopyDataTo(reinterpret_cast(dst.data())); +} + +bool ByteWriter::AddDataFromFile(PropertyType key, const string& filePath) +{ + IF_TRUE_RETURN_VAL_WITH_MSG(filePath.length() <= 0, false, "no prop file"); + ifstream ifs(filePath, ios::binary); + IF_TRUE_RETURN_VAL_WITH_MSG(!ifs.is_open(), false, "cannot open %{public}s", filePath.c_str()); + size_t fileSize = GetFileSizeInBytes(ifs); + static constexpr size_t BYTE_TO_STORE_BUFFER_SIZE = 4; + std::size_t dataSize = sizeof(key) + BYTE_TO_STORE_BUFFER_SIZE + fileSize; + uint8_t* p = new uint8_t[dataSize]; + IF_TRUE_RETURN_VAL(p == nullptr, false); + data_.emplace_back(DataBlock { + .data = p, + .len = dataSize + }); + totalSize_ += dataSize; + errno_t ret = memset_s(p, dataSize, 0, dataSize); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != EOK, false, "failed to init mem"); + size_t offset = 0; + ret = memcpy_s(p + offset, sizeof(key), reinterpret_cast(&key), sizeof(key)); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != EOK, false, "failed to copy key"); + offset += sizeof(key); + ret = memcpy_s(p + offset, BYTE_TO_STORE_BUFFER_SIZE, + reinterpret_cast(&fileSize), BYTE_TO_STORE_BUFFER_SIZE); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != EOK, false, "failed to copy buffer size"); + offset += BYTE_TO_STORE_BUFFER_SIZE; + ifs.read(reinterpret_cast(p) + offset, fileSize); + return true; +} + +bool ByteWriter::Finalize(SharedBuffer& buffer) +{ + int fd = AshmemCreate("ForMetaProp", totalSize_); + IF_TRUE_RETURN_VAL_WITH_MSG(fd < 0, false, "cannot create ashmem for meta prop"); + void *addr = mmap(nullptr, totalSize_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (addr == nullptr) { + HDF_LOGE("failed to map addr for meta prop"); + close(fd); + return false; + } + bool flag = CopyDataTo(reinterpret_cast(addr)); + if (munmap(addr, totalSize_) != 0) { + HDF_LOGW("failed to unmap addr for meta prop"); + } + if (flag) { + buffer.fd = fd; + buffer.filledLen = static_cast(totalSize_); + buffer.capacity = static_cast(AshmemGetSize(fd)); + return true; + } + return false; +} +} \ No newline at end of file diff --git a/codec/test/demo/heif/src/codec_heif_helper.cpp b/codec/test/demo/heif/src/codec_heif_helper.cpp new file mode 100644 index 0000000000..f9a9341930 --- /dev/null +++ b/codec/test/demo/heif/src/codec_heif_helper.cpp @@ -0,0 +1,349 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "codec_heif_helper.h" + +namespace OHOS::VDI::HEIF { +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace std; + +void HeifEncoderHelper::DoEncode() +{ + HDF_LOGI("start heif encode"); + Reset(); + bool flag = false; + if (encodeOpt_.gainMapPath.length() > 0) { + HDF_LOGI("AssembleParamForTmap"); + flag = AssembleParamForTmap(); + } else { + HDF_LOGI("AssembleParamForPrimaryImg"); + flag = AssembleParamForPrimaryImg(); + } + IF_TRUE_RETURN(!flag); + HDF_LOGI("get ICodecImage"); + sptr hdiHeifEncoder = ICodecImage::Get(); + IF_TRUE_RETURN_WITH_MSG(hdiHeifEncoder == nullptr, "failed to get ICodecImage"); + SharedBuffer output; + IF_TRUE_RETURN(!AllocOutputBuffer(output)); + uint32_t filledLen = 0; + HDF_LOGI("DoHeifEncode"); + int32_t ret = hdiHeifEncoder->DoHeifEncode(inputImgs_, inputMetas_, refs_, output, filledLen); + if (ret == HDF_SUCCESS) { + HDF_LOGI("heif encode succeed"); + output.filledLen = filledLen; + bufferHelper_.DumpBuffer(encodeOpt_.outputPath, output); + } else { + HDF_LOGE("heif encode failed"); + } + close(output.fd); +} + +bool HeifEncoderHelper::AllocOutputBuffer(SharedBuffer& output) +{ + static constexpr size_t EXTERNAL_BUFFER_SIZE = 18 * 1024 * 1024; + int fd = AshmemCreate("ForHeifEditOut", EXTERNAL_BUFFER_SIZE); + bool flag = true; + if (fd >= 0) { + output.fd = fd; + output.capacity = static_cast(AshmemGetSize(fd)); + } else { + flag = false; + output.fd = -1; + output.capacity = 0; + HDF_LOGE("failed to create output buffer"); + } + output.filledLen = 0; + return flag; +} + + +void HeifEncoderHelper::Reset() +{ + inputImgs_.clear(); + inputMetas_.clear(); + refs_.clear(); +} + +bool HeifEncoderHelper::AddPropOnlyForTmap(ByteWriter& bw) +{ + MasteringDisplayColourVolume clrVol = { + .displayPrimariesRX = 1, + .displayPrimariesRY = 2, + .displayPrimariesGX = 3, + .displayPrimariesGY = 4, + .displayPrimariesBX = 5, + .displayPrimariesBY = 6, + .whitePointX = 0, + .whitePointY = 0, + .maxDisplayMasteringLuminance = 0, + .minDisplayMasteringLuminance = 0 + }; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(MASTER_DISPLAY_COLOR_VOLUME, clrVol), false, + "failed to add MASTER_DISPLAY_COLOR_VOLUME"); + HDF_LOGI("add MASTER_DISPLAY_COLOR_VOLUME succeed"); + + ToneMapMetadata tmapMeta; + static constexpr uint8_t MULTI_CHANNEL = 3; + tmapMeta.channelCnt = MULTI_CHANNEL; + tmapMeta.useBaseColorSpace = true; + tmapMeta.baseHdrHeadroom = {12, 23}; + tmapMeta.alternateHdrHeadroom = {36, 62}; + tmapMeta.channels1 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + tmapMeta.channels2 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + tmapMeta.channels3 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(TONE_MAP_METADATA, tmapMeta), false, + "failed to add TONE_MAP_METADATA"); + HDF_LOGI("add TONE_MAP_METADATA succeed"); + return true; +} + +bool HeifEncoderHelper::AddPropMirrorAndRotate(ByteWriter& bw) +{ + static map mirrorMap = { + { ImageMirror::HORIZONTAL, false }, + { ImageMirror::VERTICAL, true }, + }; + auto iterMirror = mirrorMap.find(encodeOpt_.mirrorInfo); + if (iterMirror != mirrorMap.end()) { + bool isMirrorVertical = iterMirror->second; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(MIRROR_INFO, isMirrorVertical), false, + "failed to add MIRROR_INFO"); + HDF_LOGI("add MIRROR_INFO succeed"); + } + + static map rotateMap = { + { ImageRotation::ANTI_CLOCKWISE_90, 90 }, + { ImageRotation::ANTI_CLOCKWISE_180, 180 }, + { ImageRotation::ANTI_CLOCKWISE_270, 270 }, + }; + auto iterRotate = rotateMap.find(encodeOpt_.rotateInfo); + if (iterRotate != rotateMap.end()) { + uint32_t rotateDegree = iterRotate->second; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(ROTATE_INFO, rotateDegree), false, + "failed to add ROTATE_INFO"); + HDF_LOGI("add ROTATE_INFO succeed"); + } + return true; +} + +bool HeifEncoderHelper::CreateImgParam(ImgType type, vector& props) +{ + ByteWriter bw; + + if (type != T_MAP) { + IF_TRUE_RETURN_VAL(!AddPropMirrorAndRotate(bw), false); + } + + ColorType clrType = encodeOpt_.iccProfilePath.length() > 0 ? PROF : NCLX; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(COLOR_TYPE, clrType), false, "failed to add COLOR_TYPE"); + HDF_LOGI("add COLOR_TYPE succeed"); + + if (clrType == NCLX) { + ColourInfo clrInfo = { + .colourPrimaries = 2, + .transferCharacteristics = 2, + .matrixCoefficients = 2, + .fullRangeFlag = false + }; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(COLOR_INFO, clrInfo), false, "failed to add COLOR_INFO"); + HDF_LOGI("add COLOR_INFO succeed"); + } + + if (type == T_MAP || type == PRIMARY_IMG) { + ContentLightLevel level = { + .maxContentLightLevel = 1, + .maxPicAverageLightLevel = 2 + }; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(CONTENT_LIGHT_LEVEL, level), false, + "failed to add CONTENT_LIGHT_LEVEL"); + HDF_LOGI("add CONTENT_LIGHT_LEVEL succeed"); + } + + if (type == T_MAP) { + IF_TRUE_RETURN_VAL(!AddPropOnlyForTmap(bw), false); + } + + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.Finalize(props), false, "failed to write img prop"); + return true; +} + +bool HeifEncoderHelper::FillImageItem(ImgType type, ImageItem& item) +{ + map typeToFile = { + { PRIMARY_IMG, encodeOpt_.primaryImgPath }, + { AUXILIARY_IMG, encodeOpt_.auxiliaryImgPath }, + { THUMBNAIL_IMG, encodeOpt_.thumbnailImgPath }, + { GAIN_MAP, encodeOpt_.gainMapPath }, + { T_MAP, "" }, + }; + item.itemName = ""; + item.id = GetNextId(); + item.sharedProperties = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + item.pixelBuffer = bufferHelper_.CreateImgBuffer(typeToFile[type]); + IF_TRUE_RETURN_VAL((type != T_MAP && item.pixelBuffer == nullptr), false); + item.isPrimary = (type == PRIMARY_IMG); + item.isHidden = (type != PRIMARY_IMG); + item.compressType = (type == T_MAP ? "none" : "hevc"); + static constexpr uint32_t ENCODE_QUALITY = 85; + item.quality = ENCODE_QUALITY; + IF_TRUE_RETURN_VAL(!CreateImgParam(type, item.liteProperties), false); + map sharedProps; + if (encodeOpt_.iccProfilePath.length() > 0) { + HDF_LOGI("add ICC_PROFILE"); + sharedProps[ICC_PROFILE] = encodeOpt_.iccProfilePath; + } + if (type == T_MAP && encodeOpt_.it35Path.length() > 0) { + HDF_LOGI("add IT35_INFO"); + sharedProps[IT35_INFO] = encodeOpt_.it35Path; + } + IF_TRUE_RETURN_VAL(sharedProps.empty(), true); + item.sharedProperties = bufferHelper_.CreateSharedBuffer(sharedProps); + return (item.sharedProperties.fd >= 0); +} + +bool HeifEncoderHelper::AssembleParamForOtherImg(uint32_t primaryImgId) +{ + if (encodeOpt_.auxiliaryImgPath.length() > 0) { + ImageItem itemAuxlImg; + IF_TRUE_RETURN_VAL(!FillImageItem(AUXILIARY_IMG, itemAuxlImg), false); + inputImgs_.emplace_back(itemAuxlImg); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = itemAuxlImg.id, + .to = {primaryImgId} + }); + } + if (encodeOpt_.thumbnailImgPath.length() > 0) { + ImageItem itemThmbImg; + IF_TRUE_RETURN_VAL(!FillImageItem(THUMBNAIL_IMG, itemThmbImg), false); + inputImgs_.emplace_back(itemThmbImg); + refs_.emplace_back(ItemRef { + .type = THMB, + .auxType = "", + .from = itemThmbImg.id, + .to = {primaryImgId} + }); + } + return true; +} + +bool HeifEncoderHelper::AssembleParamForTmap() +{ + ImageItem itemTmap; + ImageItem itemPrimaryImg; + ImageItem itemGainMap; + IF_TRUE_RETURN_VAL(!FillImageItem(T_MAP, itemTmap), false); + IF_TRUE_RETURN_VAL(!FillImageItem(PRIMARY_IMG, itemPrimaryImg), false); + IF_TRUE_RETURN_VAL(!FillImageItem(GAIN_MAP, itemGainMap), false); + inputImgs_.emplace_back(itemTmap); + inputImgs_.emplace_back(itemPrimaryImg); + inputImgs_.emplace_back(itemGainMap); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = itemTmap.id, + .to = {itemPrimaryImg.id, itemGainMap.id} + }); + if (AssembleParamForOtherImg(itemPrimaryImg.id)) { + return AssembleParamForMetaData(itemPrimaryImg.id); + } + return false; +} + +bool HeifEncoderHelper::AssembleParamForPrimaryImg() +{ + ImageItem itemPrimaryImg; + IF_TRUE_RETURN_VAL(!FillImageItem(PRIMARY_IMG, itemPrimaryImg), false); + inputImgs_.emplace_back(itemPrimaryImg); + if (AssembleParamForOtherImg(itemPrimaryImg.id)) { + return AssembleParamForMetaData(itemPrimaryImg.id); + } + return false; +} + +bool HeifEncoderHelper::FillMetaItem(const string& metaFile, MetaType type, MetaItem& item) +{ + item.itemName = ""; + item.id = GetNextId(); + item.properties = {}; + if (type == USER_DATA) { + static constexpr char USER_DATA_LABEL[] = "userdata"; + item.itemName = USER_DATA_LABEL; + bool useCompress = true; + ByteWriter bw; + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.AddData(USER_DATA_DO_COMPRESS, useCompress), false, + "failed to add USER_DATA_DO_COMPRESS"); + IF_TRUE_RETURN_VAL_WITH_MSG(!bw.Finalize(item.properties), false, "failed to write USER_DATA_DO_COMPRESS"); + } else if (type == EXIF_DATA) { + static constexpr char EXIF_LABEL[] = "exif"; + item.itemName = EXIF_LABEL; + } + item.data = bufferHelper_.CreateSharedBuffer(metaFile); + return (item.data.fd >= 0); +} + +bool HeifEncoderHelper::AssembleParamForMetaData(uint32_t primaryImgId) +{ + HDF_LOGI("AssembleParamForMetaData"); + if (encodeOpt_.exifDataPath.length() > 0) { + HDF_LOGI("add exif: %{public}s", encodeOpt_.exifDataPath.c_str()); + MetaItem metaExifData; + IF_TRUE_RETURN_VAL(!FillMetaItem(encodeOpt_.exifDataPath, EXIF_DATA, metaExifData), false); + inputMetas_.emplace_back(metaExifData); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaExifData.id, + .to = {primaryImgId} + }); + } + if (encodeOpt_.userDataPath.length() > 0) { + HDF_LOGI("add userData: %{public}s", encodeOpt_.userDataPath.c_str()); + MetaItem metaUserData; + IF_TRUE_RETURN_VAL(!FillMetaItem(encodeOpt_.userDataPath, USER_DATA, metaUserData), false); + inputMetas_.emplace_back(metaUserData); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = {primaryImgId} + }); + } + return true; +} +} diff --git a/codec/test/demo/heif/src/command_parser.cpp b/codec/test/demo/heif/src/command_parser.cpp new file mode 100644 index 0000000000..3507f4ac5d --- /dev/null +++ b/codec/test/demo/heif/src/command_parser.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "command_parser.h" + +namespace OHOS::VDI::HEIF { +using namespace std; + +enum ShortOption { + OPT_UNKONWN = 0, + OPT_HELP, + OPT_PRIMARY_IMG, + OPT_AUXILIARY_IMG, + OPT_THUMBNAIL_IMG, + OPT_GAIN_MAP, + OPT_EXIF_DATA, + OPT_USER_DATA, + OPT_ICC_PROFILE, + OPT_IT35, + OPT_MIRROR, + OPT_ROTATE, + OPT_OUTPUT = 'o' +}; + +static struct option g_longOptions[] = { + {"help", no_argument, nullptr, static_cast(ShortOption::OPT_HELP)}, + {"primaryImg", required_argument, nullptr, static_cast(ShortOption::OPT_PRIMARY_IMG)}, + {"auxiliaryImg", required_argument, nullptr, static_cast(ShortOption::OPT_AUXILIARY_IMG)}, + {"thumbnailImg", required_argument, nullptr, static_cast(ShortOption::OPT_THUMBNAIL_IMG)}, + {"gainMap", required_argument, nullptr, static_cast(ShortOption::OPT_GAIN_MAP)}, + {"exifData", required_argument, nullptr, static_cast(ShortOption::OPT_EXIF_DATA)}, + {"userData", required_argument, nullptr, static_cast(ShortOption::OPT_USER_DATA)}, + {"iccProfile", required_argument, nullptr, static_cast(ShortOption::OPT_ICC_PROFILE)}, + {"it35", required_argument, nullptr, static_cast(ShortOption::OPT_IT35)}, + {"mirror", required_argument, nullptr, static_cast(ShortOption::OPT_MIRROR)}, + {"rotate", required_argument, nullptr, static_cast(ShortOption::OPT_ROTATE)}, + {"out", required_argument, nullptr, static_cast(ShortOption::OPT_OUTPUT)}, + {nullptr, no_argument, nullptr, static_cast(ShortOption::OPT_UNKONWN)}, +}; + +void ShowUsage() +{ + std::string rotateValueOpt = "0: ANTI_CLOCKWISE_90, 1: ANTI_CLOCKWISE_180, 2: ANTI_CLOCKWISE_270"; + std::cout << "Heif Hardware encode Demo Options:" << std::endl; + std::cout << " --help help info." << std::endl; + std::cout << " --primaryImg full path for primary image file." << std::endl; + std::cout << " --auxiliaryImg (optional) full path for auxiliary image file." << std::endl; + std::cout << " --thumbnailImg (optional) full path for thumbnail image file." << std::endl; + std::cout << " --gainMap (optional) full path for gainMap file." << std::endl; + std::cout << " --exifData (optional) full path for exifData file." << std::endl; + std::cout << " --userData (optional) full path for userData file." << std::endl; + std::cout << " --iccProfile (optional) full path for iccProfile file." << std::endl; + std::cout << " --it35 (optional) full path for it35 file." << std::endl; + std::cout << " --mirror (optional) image mirror info. 0: HORIZONTAL, 1: VERTICAL" << std::endl; + std::cout << " --rotate (optional) image rotate info. " << rotateValueOpt << std::endl; + std::cout << " -o, --out (optional) full path for output file." << std::endl; +} + +CommandOpt Parse(int argc, char *argv[]) +{ + CommandOpt opt; + int c; + while ((c = getopt_long(argc, argv, "o:", g_longOptions, nullptr)) != -1) { + switch (static_cast(c)) { + case ShortOption::OPT_HELP: + ShowUsage(); + break; + case ShortOption::OPT_PRIMARY_IMG: + opt.primaryImgPath = string(optarg); + break; + case ShortOption::OPT_AUXILIARY_IMG: + opt.auxiliaryImgPath = string(optarg); + break; + case ShortOption::OPT_THUMBNAIL_IMG: + opt.thumbnailImgPath = string(optarg); + break; + case ShortOption::OPT_GAIN_MAP: + opt.gainMapPath = string(optarg); + break; + case ShortOption::OPT_EXIF_DATA: + opt.exifDataPath = string(optarg); + break; + case ShortOption::OPT_USER_DATA: + opt.userDataPath = string(optarg); + break; + case ShortOption::OPT_ICC_PROFILE: + opt.iccProfilePath = string(optarg); + break; + case ShortOption::OPT_IT35: + opt.it35Path = string(optarg); + break; + case ShortOption::OPT_MIRROR: + opt.mirrorInfo = static_cast(stol(optarg)); + break; + case ShortOption::OPT_ROTATE: + opt.rotateInfo = static_cast(stol(optarg)); + break; + case ShortOption::OPT_OUTPUT: + opt.outputPath = string(optarg); + break; + default: + break; + } + } + return opt; +} + +static string GetMirrorPrintInfo(ImageMirror info) +{ + if (info == ImageMirror::NONE) { + return "ImageMirror::NONE"; + } + if (info == ImageMirror::HORIZONTAL) { + return "ImageMirror::HORIZONTAL"; + } + if (info == ImageMirror::VERTICAL) { + return "ImageMirror::VERTICAL"; + } + return "unknown mirror info"; +} + +static string GetRotatePrintInfo(ImageRotation info) +{ + if (info == ImageRotation::NONE) { + return "ImageRotation::NONE"; + } + if (info == ImageRotation::ANTI_CLOCKWISE_90) { + return "ImageRotation::ANTI_CLOCKWISE_90"; + } + if (info == ImageRotation::ANTI_CLOCKWISE_180) { + return "ImageRotation::ANTI_CLOCKWISE_180"; + } + if (info == ImageRotation::ANTI_CLOCKWISE_270) { + return "ImageRotation::ANTI_CLOCKWISE_270"; + } + return "unknown rotate info"; +} + +void CommandOpt::Print() const +{ + std::cout << "=========================== OPT INFO ===========================" << endl; + std::cout << " primaryImgPath : " << primaryImgPath << endl; + std::cout << " auxiliaryImgPath : " << auxiliaryImgPath << endl; + std::cout << " thumbnailImgPath : " << thumbnailImgPath << endl; + std::cout << " gainMapPath : " << gainMapPath << endl; + std::cout << " exifDataPath : " << exifDataPath << endl; + std::cout << " userDataPath : " << userDataPath << endl; + std::cout << " iccProfilePath : " << iccProfilePath << endl; + std::cout << " it35Path : " << it35Path << endl; + std::cout << " mirrorInfo : " << GetMirrorPrintInfo(mirrorInfo) << endl; + std::cout << " rotateInfo : " << GetRotatePrintInfo(rotateInfo) << endl; + std::cout << " outputPath : " << outputPath << endl; + std::cout << "=================================================================" << endl; +} +} diff --git a/codec/test/demo/heif/src/heif_encoder.cpp b/codec/test/demo/heif/src/heif_encoder.cpp new file mode 100644 index 0000000000..1dbffd8578 --- /dev/null +++ b/codec/test/demo/heif/src/heif_encoder.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "codec_heif_helper.h" + +int main(int argc, char *argv[]) +{ + OHOS::VDI::HEIF::CommandOpt opt = OHOS::VDI::HEIF::Parse(argc, argv); + opt.Print(); + OHOS::VDI::HEIF::HeifEncoderHelper obj(opt); + obj.DoEncode(); + return 0; +} \ No newline at end of file diff --git a/codec/test/demo/jpeg/BUILD.gn b/codec/test/demo/jpeg/BUILD.gn index 0f5f25f09a..f5c649ec09 100644 --- a/codec/test/demo/jpeg/BUILD.gn +++ b/codec/test/demo/jpeg/BUILD.gn @@ -25,7 +25,7 @@ ohos_executable("codec_jpeg_decode") { if (is_standard_system) { external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_composer_hdi_impl", diff --git a/codec/test/demo/jpeg/include/codec_jpeg_helper.h b/codec/test/demo/jpeg/include/codec_jpeg_helper.h index 435b054b1b..4c1f691284 100644 --- a/codec/test/demo/jpeg/include/codec_jpeg_helper.h +++ b/codec/test/demo/jpeg/include/codec_jpeg_helper.h @@ -13,16 +13,16 @@ * limitations under the License. */ -#ifndef OHOS_HDI_CODEC_IMAGE_V1_0_CODECJPEGHELPER_H -#define OHOS_HDI_CODEC_IMAGE_V1_0_CODECJPEGHELPER_H +#ifndef OHOS_HDI_CODEC_IMAGE_V2_0_CODECJPEGHELPER_H +#define OHOS_HDI_CODEC_IMAGE_V2_0_CODECJPEGHELPER_H #include -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" #include namespace OHOS { namespace HDI { namespace Codec { namespace Image { -namespace V1_0 { +namespace V2_0 { class CodecJpegHelper { public: enum JpegMarker : int16_t { @@ -68,4 +68,4 @@ private: } } } -#endif // OHOS_HDI_CODEC_IMAGE_V1_0_CODECJPEGHELPER_H +#endif // OHOS_HDI_CODEC_IMAGE_V2_0_CODECJPEGHELPER_H diff --git a/codec/test/demo/jpeg/include/jpeg_decoder.h b/codec/test/demo/jpeg/include/jpeg_decoder.h index dbcdcc625b..16a17440b3 100644 --- a/codec/test/demo/jpeg/include/jpeg_decoder.h +++ b/codec/test/demo/jpeg/include/jpeg_decoder.h @@ -24,7 +24,7 @@ #include "v1_0/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "v1_0/include/idisplay_buffer.h" -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" class JpegDecoder { public: @@ -51,18 +51,18 @@ private: } private: - OHOS::sptr hdiJpeg_; + OHOS::sptr hdiJpeg_; OHOS::HDI::Display::Buffer::V1_0::IDisplayBuffer *hdiBuffer_; - OHOS::HDI::Codec::Image::V1_0::CodecJpegHelper *helper_ = nullptr; - OHOS::HDI::Codec::Image::V1_0::CodecImageBuffer inBuffer_; - OHOS::HDI::Codec::Image::V1_0::CodecImageBuffer outBuffer_; + OHOS::HDI::Codec::Image::V2_0::CodecJpegHelper *helper_ = nullptr; + OHOS::HDI::Codec::Image::V2_0::CodecImageBuffer inBuffer_; + OHOS::HDI::Codec::Image::V2_0::CodecImageBuffer outBuffer_; std::unique_ptr jpegBuffer_; std::ifstream ioIn_; std::ofstream ioOut_; uint32_t dataStart_; uint32_t bufferLen_; uint32_t compDataLen_; - OHOS::HDI::Codec::Image::V1_0::CodecJpegDecInfo decInfo_; + OHOS::HDI::Codec::Image::V2_0::CodecJpegDecInfo decInfo_; std::unique_ptr compressBuffer_; uint32_t alignment_ = 16; }; diff --git a/codec/test/demo/jpeg/src/codec_jpeg_helper.cpp b/codec/test/demo/jpeg/src/codec_jpeg_helper.cpp index eee9cb9171..304b36d0f2 100644 --- a/codec/test/demo/jpeg/src/codec_jpeg_helper.cpp +++ b/codec/test/demo/jpeg/src/codec_jpeg_helper.cpp @@ -30,7 +30,7 @@ static int8_t UnZigZagTable[64] = { 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63}; -using namespace OHOS::HDI::Codec::Image::V1_0; +using namespace OHOS::HDI::Codec::Image::V2_0; int32_t CodecJpegHelper::JpegAssemble(const struct CodecJpegDecInfo &decInfo, int8_t *buffer, int32_t fd) { HDF_LOGI("enter"); diff --git a/codec/test/demo/jpeg/src/jpeg_decoder.cpp b/codec/test/demo/jpeg/src/jpeg_decoder.cpp index f3f4cedebf..a045bb2332 100644 --- a/codec/test/demo/jpeg/src/jpeg_decoder.cpp +++ b/codec/test/demo/jpeg/src/jpeg_decoder.cpp @@ -22,7 +22,7 @@ #include "jpeg_decoder.h" #define HDF_LOG_TAG codec_jpeg_decoder -using namespace OHOS::HDI::Codec::Image::V1_0; +using namespace OHOS::HDI::Codec::Image::V2_0; using namespace OHOS::HDI::Display::Buffer::V1_0; using namespace OHOS::HDI::Display::Composer::V1_0; diff --git a/codec/test/fuzztest/image_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/BUILD.gn index 3add89f8e1..c03bcf54ca 100644 --- a/codec/test/fuzztest/image_fuzzer/BUILD.gn +++ b/codec/test/fuzztest/image_fuzzer/BUILD.gn @@ -13,10 +13,11 @@ import("../../../codec.gni") -group("hdf_jpeg_fuzz_test") { +group("hdf_image_fuzz_test") { testonly = true deps = [ "imageallocateinbuffer_fuzzer:fuzztest", + "imagedoheifencode_fuzzer:fuzztest", "imagedojpegdecode_fuzzer:fuzztest", "imagefreeinbuffer_fuzzer:fuzztest", "imagegetcapability_fuzzer:fuzztest", diff --git a/codec/test/fuzztest/image_fuzzer/common/include/encode_buffer_helper.h b/codec/test/fuzztest/image_fuzzer/common/include/encode_buffer_helper.h new file mode 100644 index 0000000000..c251f7d8b8 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/common/include/encode_buffer_helper.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef ENCODE_BUFFER_HELPER_FUZZ +#define ENCODE_BUFFER_HELPER_FUZZ + +#include +#include +#include +#include +#include "log.h" +#include "v2_0/icodec_image.h" +#include "v1_2/display_composer_type.h" +#include "v1_2/display_buffer_type.h" +#include "v1_2/include/idisplay_buffer.h" + +namespace OHOS::VDI::HEIF { +uint32_t ToUint32(const uint8_t* ptr); +class EncodeBufferHelper { +public: + EncodeBufferHelper(); + ~EncodeBufferHelper(); + OHOS::sptr CreateImgBuffer(uint8_t* data, size_t size); + OHOS::HDI::Codec::Image::V2_0::SharedBuffer CreateSharedBuffer(uint8_t* data, size_t size); +private: + struct PixelFileInfo { + uint32_t displayWidth; + uint32_t alignedWidth; + uint32_t displayHeight; + uint32_t alignedHeight; + int32_t pixFmt; + }; +private: + bool InitialRgbaData(BufferHandle* handle, PixelFileInfo& pixelInfo, uint8_t* data, size_t size); +private: + OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer* bufferMgr_; + std::set allocatedFd_; +}; +} // OHOS::VDI::HEIF + +#endif // ENCODE_BUFFER_HELPER_FUZZ \ No newline at end of file diff --git a/codec/test/fuzztest/image_fuzzer/common/include/encode_heif_helper.h b/codec/test/fuzztest/image_fuzzer/common/include/encode_heif_helper.h new file mode 100644 index 0000000000..cdf753fd20 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/common/include/encode_heif_helper.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef ENCODE_HEIF_HELPER_FUZZ +#define ENCODE_HEIF_HELPER_FUZZ + +#include +#include "encode_buffer_helper.h" + +namespace OHOS::VDI::HEIF { +enum ImgType { + PRIMARY_IMG, + AUXILIARY_IMG, + THUMBNAIL_IMG, + GAIN_MAP, + T_MAP +}; +enum MetaType { + EXIF_DATA, + USER_DATA +}; +class HeifEncodeHelper { +public: + HeifEncodeHelper() {}; + ~HeifEncodeHelper() {}; + void Reset(); + bool AssembleParamForTmap(uint8_t *data, size_t size); + bool AssembleParamForPrimaryImg(uint8_t *data, size_t size); + bool AssembleParamForOtherImg(uint32_t primaryImgId, uint8_t *data, size_t size); + bool AssembleParamForMetaData(uint32_t primaryImgId, uint8_t *data, size_t size); + bool FillImageItem(ImgType type, OHOS::HDI::Codec::Image::V2_0::ImageItem& item, uint8_t *data, size_t size); + OHOS::HDI::Codec::Image::V2_0::ItemRef FillRefItem(OHOS::HDI::Codec::Image::V2_0::ItemRef item, + uint8_t *data, size_t size); + bool FillMetaItem(MetaType type, OHOS::HDI::Codec::Image::V2_0::MetaItem& item, uint8_t *data, size_t size); + bool AllocOutputBuffer(OHOS::HDI::Codec::Image::V2_0::SharedBuffer& output); +public: + std::vector inputImgs_; + std::vector inputMetas_; + std::vector refs_; + uint32_t id_ = 0; + EncodeBufferHelper bufferHelper_; +}; +} // OHOS::VDI::HEIF +#endif // ENCODE_HEIF_HELPER_FUZZ \ No newline at end of file diff --git a/codec/test/fuzztest/image_fuzzer/common/image_auto_initer.h b/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h similarity index 79% rename from codec/test/fuzztest/image_fuzzer/common/image_auto_initer.h rename to codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h index 3f63f18d1d..b23c6ae688 100644 --- a/codec/test/fuzztest/image_fuzzer/common/image_auto_initer.h +++ b/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h @@ -15,14 +15,14 @@ #ifndef IMAGE_AUTO_INITER #define IMAGE_AUTO_INITER -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" namespace OHOS { namespace Codec { namespace Image { class ImageAutoIniter { public: - ImageAutoIniter(OHOS::sptr imageClient, - OHOS::HDI::Codec::Image::V1_0::CodecImageRole role) : client_(imageClient), role_(role) + ImageAutoIniter(OHOS::sptr imageClient, + OHOS::HDI::Codec::Image::V2_0::CodecImageRole role) : client_(imageClient), role_(role) { if (client_) { client_->Init(role_); @@ -38,8 +38,8 @@ public: } private: - OHOS::sptr client_; - OHOS::HDI::Codec::Image::V1_0::CodecImageRole role_; + OHOS::sptr client_; + OHOS::HDI::Codec::Image::V2_0::CodecImageRole role_; }; } // namespace Image } // namespace Codec diff --git a/codec/test/fuzztest/image_fuzzer/common/image_common.h b/codec/test/fuzztest/image_fuzzer/common/include/image_common.h similarity index 93% rename from codec/test/fuzztest/image_fuzzer/common/image_common.h rename to codec/test/fuzztest/image_fuzzer/common/include/image_common.h index 36a880ecdf..657c82c318 100644 --- a/codec/test/fuzztest/image_fuzzer/common/image_common.h +++ b/codec/test/fuzztest/image_fuzzer/common/include/image_common.h @@ -15,7 +15,7 @@ #ifndef IMAGE_COMMON_H #define IMAGE_COMMON_H -#include "v1_0/codec_image_type.h" +#include "v2_0/codec_image_type.h" namespace OHOS { namespace Codec { namespace Image { @@ -33,7 +33,7 @@ static const int32_t DATA_PTS = 200; static const int32_t DATA_FLAG = 300; static const int32_t TESTING_APP_DATA = 33; -void FillDataImageBuffer(HDI::Codec::Image::V1_0::CodecImageBuffer &dataFuzz) +void FillDataImageBuffer(HDI::Codec::Image::V2_0::CodecImageBuffer &dataFuzz) { dataFuzz.id = DATA_BUFFERID; dataFuzz.size = DATA_SIZE; diff --git a/codec/test/fuzztest/image_fuzzer/common/include/log.h b/codec/test/fuzztest/image_fuzzer/common/include/log.h new file mode 100644 index 0000000000..36bf17091c --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/common/include/log.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ENCODE_HEIF_LOG_FUZZ +#define ENCODE_HEIF_LOG_FUZZ + +#include "hdf_log.h" +#define HDF_LOG_TAG codec_heif_encoder + +#define IF_TRUE_RETURN(cond) \ + do { \ + if (cond) { \ + return; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_WITH_MSG(cond, msg, ...) \ + do { \ + if (cond) { \ + HDF_LOGE(msg, ##__VA_ARGS__); \ + return; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_VAL(cond, val) \ + do { \ + if (cond) { \ + return val; \ + } \ + } while (0) + +#define IF_TRUE_RETURN_VAL_WITH_MSG(cond, val, msg, ...) \ + do { \ + if (cond) { \ + HDF_LOGE(msg, ##__VA_ARGS__); \ + return val; \ + } \ + } while (0) + +#endif // ENCODE_HEIF_LOG_FUZZ \ No newline at end of file diff --git a/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp b/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp new file mode 100644 index 0000000000..23586b305a --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "ashmem.h" +#include "encode_buffer_helper.h" + +namespace OHOS::VDI::HEIF { +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace OHOS::HDI::Display::Buffer::V1_2; +using namespace OHOS::HDI::Display::Composer::V1_2; +using namespace std; + +uint32_t ToUint32(const uint8_t* ptr) +{ + if (ptr == nullptr) { + return 0; + } + return (ptr[0] << 24) | (ptr[1] << 16) | // 24:bit offset, 16: bit offset, 1:byte offset + (ptr[2] << 8) | (ptr[3]); // 8:bit offset, 2: byte offset, 3:byte offset +} + +EncodeBufferHelper::EncodeBufferHelper() +{ + bufferMgr_ = OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer::Get(); +} + +EncodeBufferHelper::~EncodeBufferHelper() +{ + bufferMgr_ = nullptr; + for (auto iter = allocatedFd_.begin(); iter != allocatedFd_.end(); ++iter) { + close(*iter); + } + allocatedFd_.clear(); +} + + +bool EncodeBufferHelper::InitialRgbaData(BufferHandle* handle, PixelFileInfo& pixelInfo, uint8_t* data, size_t size) +{ + char* dst = reinterpret_cast(handle->virAddr); + static constexpr uint32_t BYTES_PER_PIXEL_RBGA = 4; + errno_t ret = EOK; + uint8_t* dataEnd = data + size -1; + if (dataEnd < data + pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA * pixelInfo.displayHeight) { + return false; + HDF_LOGI("Input Data length Not Enough"); + } + for (uint32_t i = 0; i < pixelInfo.displayHeight; i++) { + ret = memcpy_s(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA, data, + pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA); + dst += handle->stride; + } + data += pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA * pixelInfo.displayHeight; + return (ret == EOK); +} + +sptr EncodeBufferHelper::CreateImgBuffer(uint8_t* data, size_t size) +{ + PixelFileInfo pixelInfo; + uint8_t* dataEnd = data + size -1; + if (dataEnd < data + sizeof(pixelInfo.displayWidth)) { + return nullptr; + } + static constexpr int SHIFT_CNT = 22; + pixelInfo.displayWidth = (ToUint32(data) >> SHIFT_CNT); //Max 1024 + pixelInfo.alignedWidth = pixelInfo.displayWidth; + data += sizeof(pixelInfo.displayWidth); + + if (dataEnd < data + sizeof(pixelInfo.displayHeight)) { + return nullptr; + } + pixelInfo.displayHeight = (ToUint32(data) >> SHIFT_CNT); + pixelInfo.alignedHeight = pixelInfo.displayHeight; + data += sizeof(pixelInfo.displayHeight); + + pixelInfo.pixFmt = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_RGBA_8888; + uint64_t usage = OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_READ | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_WRITE | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_MEM_DMA; + AllocInfo alloc = { + .width = pixelInfo.displayWidth, + .height = pixelInfo.displayHeight, + .usage = usage, + .format = pixelInfo.pixFmt + }; + + BufferHandle *handle = nullptr; + int32_t ret = bufferMgr_->AllocMem(alloc, handle); + IF_TRUE_RETURN_VAL_WITH_MSG(ret != HDF_SUCCESS, nullptr, + "failed to alloc output buffer, err [%{public}d] !", ret); + bufferMgr_->Mmap(*handle); + + HDF_LOGI("Fill Image RGB Data"); + bool flag = InitialRgbaData(handle, pixelInfo, data, size); + + (void)bufferMgr_->Unmap(*handle); + if (!flag) { + bufferMgr_->FreeMem(*handle); + return nullptr; + } + HDF_LOGI("Fill Image RGB Data Succesfully"); + sptr imgBuffer = new NativeBuffer(handle); + return imgBuffer; +} + +SharedBuffer EncodeBufferHelper::CreateSharedBuffer(uint8_t* data, size_t size) +{ + SharedBuffer buffer = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + + uint8_t* dataEnd = data + size - 1; + if (dataEnd < data + sizeof(uint8_t)) { + return buffer; + } + uint8_t totalSize = *data; + data += sizeof(totalSize); + int fd = AshmemCreate("ForMetaData", (size_t)totalSize); + IF_TRUE_RETURN_VAL_WITH_MSG(fd < 0, buffer, "cannot create ashmem for meta data"); + void *addr = mmap(nullptr, (size_t)totalSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (addr == nullptr) { + HDF_LOGE("failed to map addr for meta buffer"); + close(fd); + return buffer; + } + if (dataEnd < data + totalSize) { + return buffer; + } + errno_t ret = EOK; + ret = memcpy_s(reinterpret_cast(addr), totalSize, data, totalSize); + if (ret != EOK) { + return buffer; + } + data += totalSize; + if (munmap(addr, totalSize) != 0) { + HDF_LOGW("failed to unmap addr for meta buffer"); + } + buffer.fd = fd; + buffer.filledLen = static_cast(totalSize); + buffer.capacity = static_cast(AshmemGetSize(fd)); + allocatedFd_.insert(fd); + return buffer; +} +} \ No newline at end of file diff --git a/codec/test/fuzztest/image_fuzzer/common/src/encode_heif_helper.cpp b/codec/test/fuzztest/image_fuzzer/common/src/encode_heif_helper.cpp new file mode 100644 index 0000000000..d709029896 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/common/src/encode_heif_helper.cpp @@ -0,0 +1,345 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "encode_heif_helper.h" + +namespace OHOS::VDI::HEIF { +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace std; + + +bool HeifEncodeHelper::AllocOutputBuffer(SharedBuffer& output) +{ + static constexpr size_t EXTERNAL_BUFFER_SIZE = 18 * 1024 * 1024; + int fd = AshmemCreate("ForHeifEditOut", EXTERNAL_BUFFER_SIZE); + bool flag = true; + if (fd >= 0) { + output.fd = fd; + output.capacity = static_cast(AshmemGetSize(fd)); + } else { + flag = false; + output.fd = -1; + output.capacity = 0; + HDF_LOGE("failed to create output buffer"); + } + output.filledLen = 0; + return flag; +} + + +void HeifEncodeHelper::Reset() +{ + inputImgs_.clear(); + inputMetas_.clear(); + refs_.clear(); +} + +ItemRef HeifEncodeHelper::FillRefItem(ItemRef item, uint8_t *data, size_t size) +{ + uint8_t *dataEnd = data + size - 1; + if (dataEnd < (data + sizeof(uint8_t))) { + return item; + } + enum ValueOption : uint8_t { + OPTION_0 = 0, + OPTION_1, + OPTION_2, + OPTION_3, + OPTION_BUTT + }; + switch ((*data) % OPTION_BUTT) { + case OPTION_0: + item.type = DIMG; + break; + case OPTION_1: + item.type = THMB; + break; + case OPTION_2: + item.type = AUXL; + break; + case OPTION_3: + item.type = CDSC; + break; + } + data += sizeof(uint8_t); + + if (dataEnd < data + sizeof(item.from)) { + return item; + } + item.from = ToUint32(data); + data += sizeof(item.from); + + if (dataEnd < data + sizeof(uint8_t)) { + return item; + } + uint8_t vecSize = (*data) % 2 + 1; + data += sizeof(vecSize); + if (dataEnd < (data + vecSize * sizeof(item.from))) { + return item; + } else { + while (vecSize--) { + item.to.emplace_back(ToUint32(data)); + data += sizeof(item.from); + } + } + return item; +} + +bool HeifEncodeHelper::FillImageItem(ImgType type, ImageItem& item, uint8_t *data, size_t size) +{ + uint8_t *dataEnd = data + size - 1; + item.itemName = ""; + if (dataEnd < data + sizeof(item.id)) { + return false; + } + item.id = ToUint32(data); + data += sizeof(item.id); + + item.pixelBuffer = bufferHelper_.CreateImgBuffer(data, size); + IF_TRUE_RETURN_VAL((type != T_MAP && item.pixelBuffer == nullptr), false); + item.isPrimary = (type == PRIMARY_IMG); + item.isHidden = (type != PRIMARY_IMG); + item.compressType = (type == T_MAP ? "none" : "hevc"); + + if (dataEnd < (data + sizeof(item.quality))) { + return false; + } + item.quality = ToUint32(data); + data += sizeof(item.quality); + + item.liteProperties = {}; + if (dataEnd < (data + sizeof(uint8_t))) { + return false; + } + uint8_t liteProSize = *data; + data += sizeof(liteProSize); + + if (dataEnd < data + liteProSize) { + return false; + } + + HDF_LOGI("Fill Image LiteProperties"); + while (liteProSize--) { + item.liteProperties.push_back(*data); + data += sizeof(uint8_t); + } + + item.sharedProperties = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + + if (dataEnd < (data + sizeof(uint8_t))) { + return false; + } + uint8_t decision = (*data) % 2; + data += sizeof(decision); + if (decision) { + HDF_LOGI("Fill Image SharedProperties"); + item.sharedProperties = bufferHelper_.CreateSharedBuffer(data, size); + } + return true; +} + +bool HeifEncodeHelper::AssembleParamForOtherImg(uint32_t primaryImgId, uint8_t *data, size_t size) +{ + uint8_t *dataEnd = data + size - 1; + if (dataEnd < data + sizeof(uint8_t)) { + return false; + } + uint8_t decision = (*data) % 2; + data += sizeof(uint8_t); + + if (decision == 1) { + ImageItem itemAuxlImg; + HDF_LOGI("Fill itemAuxlImg"); + if (!FillImageItem(AUXILIARY_IMG, itemAuxlImg, data, size)) { + HDF_LOGE("%{public}s: Fill itemAuxlImg failed\n", __func__); + return false; + } + HDF_LOGI("Fill itemAuxlImg Succesfully"); + inputImgs_.emplace_back(itemAuxlImg); + ItemRef refAuxl = { + .type = AUXL, + .auxType = "", + .from = itemAuxlImg.id, + .to = {primaryImgId} + }; + ItemRef newRefAulx = FillRefItem(refAuxl, data, size); + refs_.emplace_back(newRefAulx); + } else { + ImageItem itemThmbImg; + HDF_LOGI("Fill itemThmbImg"); + if (!FillImageItem(THUMBNAIL_IMG, itemThmbImg, data, size)) { + HDF_LOGE("%{public}s: Fill itemThmbImg failed\n", __func__); + return false; + } + HDF_LOGI("Fill itemThmbImg Succesfully"); + inputImgs_.emplace_back(itemThmbImg); + + ItemRef refThmb = { + .type = THMB, + .auxType = "", + .from = itemThmbImg.id, + .to = {primaryImgId} + }; + ItemRef newRefThmb = FillRefItem(refThmb, data, size); + refs_.emplace_back(newRefThmb); + } + return true; +} + +bool HeifEncodeHelper::AssembleParamForTmap(uint8_t *data, size_t size) +{ + ImageItem itemTmap; + ImageItem itemPrimaryImg; + ImageItem itemGainMap; + HDF_LOGI("AssembleParamForTmap: Fill ImageItem"); + if (!FillImageItem(T_MAP, itemTmap, data, size)) { + HDF_LOGE("%{public}s: Fill itemTmap failed\n", __func__); + return false; + } + + if (!FillImageItem(PRIMARY_IMG, itemPrimaryImg, data, size)) { + HDF_LOGE("%{public}s: Fill itemPrimaryImg failed\n", __func__); + return false; + } + + if (!FillImageItem(GAIN_MAP, itemGainMap, data, size)) { + HDF_LOGE("%{public}s: Fill itemGainMap failed\n", __func__); + return false; + } + inputImgs_.emplace_back(itemTmap); + inputImgs_.emplace_back(itemPrimaryImg); + inputImgs_.emplace_back(itemGainMap); + + ItemRef refTMap = { + .type = DIMG, + .auxType = "", + .from = itemTmap.id, + .to = {itemPrimaryImg.id, itemGainMap.id} + }; + + HDF_LOGI("AssembleParamForTmap: Fill RefItem"); + ItemRef newRefTMap = FillRefItem(refTMap, data, size); + refs_.emplace_back(newRefTMap); + + HDF_LOGI("AssembleParamForTmap: Fill OtherImg"); + if (AssembleParamForOtherImg(itemPrimaryImg.id, data, size)) { + HDF_LOGI("AssembleParamForTmap: Fill MetaData"); + return AssembleParamForMetaData(itemPrimaryImg.id, data, size); + } + return false; +} + +bool HeifEncodeHelper::AssembleParamForPrimaryImg(uint8_t *data, size_t size) +{ + ImageItem itemPrimaryImg; + HDF_LOGI("AssembleParamForPrimaryImg: Fill ImageItem"); + if (!FillImageItem(PRIMARY_IMG, itemPrimaryImg, data, size)) { + HDF_LOGE("%{public}s: Fill itemPrimaryImg failed\n", __func__); + return false; + } + inputImgs_.emplace_back(itemPrimaryImg); + HDF_LOGI("AssembleParamForPrimaryImg: Fill OtherImg"); + if (AssembleParamForOtherImg(itemPrimaryImg.id, data, size)) { + HDF_LOGI("AssembleParamForPrimaryImg: Fill MetaData"); + return AssembleParamForMetaData(itemPrimaryImg.id, data, size); + } + return true; +} + +bool HeifEncodeHelper::FillMetaItem(MetaType type, MetaItem& item, uint8_t *data, size_t size) +{ + uint8_t *dataEnd = data + size - 1; + item.itemName = ""; + if (dataEnd < data + sizeof(item.id)) { + return false; + } + item.id = ToUint32(data); + data += sizeof(item.id); + item.properties = {}; + + if (type == USER_DATA) { + static constexpr char USER_DATA_LABEL[] = "userdata"; + item.itemName = USER_DATA_LABEL; + + if (dataEnd < data + sizeof(uint8_t)) { + return false; + } + uint8_t propertiesSize = *data; + data += sizeof(propertiesSize); + + if (dataEnd < data + propertiesSize) { + return false; + } + + while (propertiesSize--) { + item.properties.emplace_back(*data); + data += sizeof(uint8_t); + } + } else if (type == EXIF_DATA) { + static constexpr char EXIF_LABEL[] = "exif"; + item.itemName = EXIF_LABEL; + } + item.data = bufferHelper_.CreateSharedBuffer(data, size); + return (item.data.fd >= 0); +} + +bool HeifEncodeHelper::AssembleParamForMetaData(uint32_t primaryImgId, uint8_t *data, size_t size) +{ + HDF_LOGI("AssembleParamForMetaData"); + uint8_t* dataEnd = data + size - 1; + if (dataEnd < data + sizeof(uint8_t)) { + return false; + } + uint8_t decision = (*data) % 2; + data += sizeof(decision); + if (decision) { + HDF_LOGI("add exif"); + MetaItem metaExifData; + HDF_LOGI("Fill Meta Item"); + IF_TRUE_RETURN_VAL(!FillMetaItem(EXIF_DATA, metaExifData, data, size), false); + inputMetas_.emplace_back(metaExifData); + ItemRef refItem1 = { + .type = CDSC, + .auxType = "", + .from = metaExifData.id, + .to = {primaryImgId} + } ; + ItemRef newRefIt1 = FillRefItem(refItem1, data, size); + refs_.emplace_back(newRefIt1); + HDF_LOGI("Fill EXIF Data Succesfully"); + } else { + HDF_LOGI("add userData"); + MetaItem metaUserData; + HDF_LOGI("Fill Meta Item"); + IF_TRUE_RETURN_VAL(!FillMetaItem(USER_DATA, metaUserData, data, size), false); + inputMetas_.emplace_back(metaUserData); + ItemRef refItem2 = { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = {primaryImgId} + } ; + ItemRef newRefIt2 = FillRefItem(refItem2, data, size); + refs_.emplace_back(newRefIt2); + HDF_LOGI("Fill USER Data Succesfully"); + } + return true; +} + +} diff --git a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/BUILD.gn index 21ecaca5af..ab1acdcc5f 100644 --- a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/BUILD.gn +++ b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/BUILD.gn @@ -22,13 +22,13 @@ ohos_fuzztest("ImageAllocateInBufferFuzzTest") { "${codec_root}/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer" include_dirs = [ - "../common", + "../common/include", "${codec_root}/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer", ] external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", diff --git a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp index e192bf224a..c2ee3d228a 100644 --- a/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imageallocateinbuffer_fuzzer/imageallocateinbuffer_fuzzer.cpp @@ -17,8 +17,8 @@ #include #include #include -#include "v1_0/icodec_image.h" -using namespace OHOS::HDI::Codec::Image::V1_0; +#include "v2_0/icodec_image.h" +using namespace OHOS::HDI::Codec::Image::V2_0; using namespace OHOS; using namespace std; namespace OHOS { diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/BUILD.gn new file mode 100644 index 0000000000..84674a84e8 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/BUILD.gn @@ -0,0 +1,62 @@ +# Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +module_output_path = "drivers_peripheral_codec/drivers_peripheral_codec" + +ohos_fuzztest("ImageDoHeifEncodeFuzzTest") { + module_out_path = module_output_path + codec_root = "../../../../" + fuzz_config_file = + "${codec_root}/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer" + + include_dirs = [ + "${codec_root}/test/fuzztest/image_fuzzer/common/include", + "${codec_root}/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer", + ] + + external_deps = [ + "c_utils:utils", + "drivers_interface_codec:libimage_proxy_2.0", + "drivers_interface_display:display_buffer_idl_headers_1.2", + "drivers_interface_display:display_composer_idl_headers_1.2", + "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_2", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hilog:libhilog", + "ipc:ipc_single", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${codec_root}/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp", + "${codec_root}/test/fuzztest/image_fuzzer/common/src/encode_heif_helper.cpp", + "imagedoheifencode_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":ImageDoHeifEncodeFuzzTest" ] +} diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/corpus/init b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/corpus/init new file mode 100644 index 0000000000..0db7271ce7 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp new file mode 100644 index 0000000000..c8323f0f7b --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "imagedoheifencode_fuzzer.h" +#include +#include +#include +#include +#include "image_common.h" +#include "encode_heif_helper.h" +#include "v2_0/icodec_image.h" +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace OHOS; +using namespace std; +namespace OHOS { +namespace Codec { +namespace Image { + + +bool DoHeifEncode(const uint8_t *data, size_t size) +{ + if (data == nullptr || size < sizeof(unsigned int)) { + return false; + } + + sptr image = ICodecImage::Get(false); + if (image == nullptr) { + HDF_LOGE("%{public}s: get ICodecImage failed\n", __func__); + return false; + } + CodecImageRole role = CodecImageRole(*data); + ImageAutoIniter autoIniter(image, role); + + uint8_t *rawData = const_cast(data); + uint8_t decision = (*rawData) % 2; + rawData += sizeof(decision); + + OHOS::VDI::HEIF::HeifEncodeHelper heifHelper; + heifHelper.Reset(); + + if (decision) { + if (!heifHelper.AssembleParamForTmap(rawData, size)) { + HDF_LOGE("%{public}s: AssembleParamForTmap failed\n", __func__); + return false; + } + } else { + if (!heifHelper.AssembleParamForPrimaryImg(rawData, size)) { + HDF_LOGE("%{public}s: AssembleParamForPrimaryImg failed\n", __func__); + return false; + } + } + + SharedBuffer output; + if (!heifHelper.AllocOutputBuffer(output)) { + HDF_LOGE("%{public}s: AllocOutputBuffer failed\n", __func__); + return false; + } + uint32_t filledLen = 0; + + auto err = image->DoHeifEncode(heifHelper.inputImgs_, heifHelper.inputMetas_, heifHelper.refs_, output, filledLen); + if (err != HDF_SUCCESS) { + HDF_LOGE("%{public}s: DOHeifEncode return %{public}d", __func__, err); + } + + return true; +} +} // namespace Image +} // namespace Codec +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::Codec::Image::DoHeifEncode(data, size); + return 0; +} diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h new file mode 100644 index 0000000000..049ceca011 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef IMAGE_DO_HEIF_ENCODE_FUZZER +#define IMAGE_DO_HEIF_ENCODE_FUZZER + +#define FUZZ_PROJECT_NAME "imagedoheifencode_fuzzer" + + +#endif diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/project.xml b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/project.xml new file mode 100644 index 0000000000..e3bc9272c5 --- /dev/null +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 64000000 + + 360 + + 2048 + + diff --git a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/BUILD.gn index 2fa0586955..fe56455b46 100644 --- a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/BUILD.gn +++ b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/BUILD.gn @@ -22,13 +22,13 @@ ohos_fuzztest("ImageDoJpegDecodeFuzzTest") { "${codec_root}/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer" include_dirs = [ - "../common", + "../common/include", "${codec_root}/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer", ] external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", diff --git a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp index dd1df861f7..7c35bce0f6 100644 --- a/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagedojpegdecode_fuzzer/imagedojpegdecode_fuzzer.cpp @@ -19,8 +19,8 @@ #include #include #include "image_common.h" -#include "v1_0/icodec_image.h" -using namespace OHOS::HDI::Codec::Image::V1_0; +#include "v2_0/icodec_image.h" +using namespace OHOS::HDI::Codec::Image::V2_0; using namespace OHOS; using namespace std; namespace OHOS { diff --git a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/BUILD.gn index 8263cc873a..5521258a2d 100644 --- a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/BUILD.gn +++ b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/BUILD.gn @@ -22,13 +22,13 @@ ohos_fuzztest("ImageFreeInBufferFuzzTest") { "${codec_root}/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer" include_dirs = [ - "../common", + "../common/include", "${codec_root}/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer", ] external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", diff --git a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp index 96cc9ac824..e0e4b2e144 100644 --- a/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagefreeinbuffer_fuzzer/imagefreeinbuffer_fuzzer.cpp @@ -18,8 +18,8 @@ #include #include #include "image_common.h" -#include "v1_0/icodec_image.h" -using namespace OHOS::HDI::Codec::Image::V1_0; +#include "v2_0/icodec_image.h" +using namespace OHOS::HDI::Codec::Image::V2_0; using namespace OHOS; using namespace std; namespace OHOS { diff --git a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/BUILD.gn b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/BUILD.gn index 43530a077d..7eb2f52f45 100644 --- a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/BUILD.gn +++ b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/BUILD.gn @@ -26,7 +26,7 @@ ohos_fuzztest("ImageGetCapabilityFuzzTest") { external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", diff --git a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp index 81d7d1d140..bdc9efcd99 100644 --- a/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagegetcapability_fuzzer/imagegetcapability_fuzzer.cpp @@ -16,8 +16,8 @@ #include "imagegetcapability_fuzzer.h" #include #include -#include "v1_0/icodec_image.h" -using namespace OHOS::HDI::Codec::Image::V1_0; +#include "v2_0/icodec_image.h" +using namespace OHOS::HDI::Codec::Image::V2_0; using namespace OHOS; using namespace std; namespace OHOS { diff --git a/codec/test/unittest/hdi_image/BUILD.gn b/codec/test/unittest/hdi_image/BUILD.gn index 762ad50e09..98b68a8baf 100644 --- a/codec/test/unittest/hdi_image/BUILD.gn +++ b/codec/test/unittest/hdi_image/BUILD.gn @@ -22,7 +22,7 @@ ohos_unittest("codec_hdi_jpeg_test") { if (is_standard_system) { external_deps = [ "c_utils:utils", - "drivers_interface_codec:libimage_proxy_1.0", + "drivers_interface_codec:libimage_proxy_2.0", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_composer_hdi_impl", @@ -40,7 +40,35 @@ ohos_unittest("codec_hdi_jpeg_test") { } } +ohos_unittest("codec_hdi_heif_encode_test") { + module_out_path = "drivers_peripheral_codec/codec" + + sources = [ "codec_hdi_heif_encode_test.cpp" ] + + if (is_standard_system) { + external_deps = [ + "c_utils:utils", + "drivers_interface_codec:libimage_proxy_2.0", + "drivers_interface_display:display_buffer_idl_headers_1.2", + "drivers_interface_display:display_composer_idl_headers_1.2", + "drivers_interface_display:libdisplay_buffer_hdi_impl_v1_2", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hilog:libhilog", + "ipc:ipc_single", + ] + } else { + external_deps = [ "hilog:libhilog" ] + } +} + group("codec_hdi_image_test") { testonly = true - deps = [ ":codec_hdi_jpeg_test" ] + deps = [ + ":codec_hdi_heif_encode_test", + ":codec_hdi_jpeg_test", + ] } diff --git a/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp b/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp new file mode 100644 index 0000000000..a87c8c5ad8 --- /dev/null +++ b/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp @@ -0,0 +1,765 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "test_helper.h" +#include "v1_2/display_composer_type.h" +#include "v1_2/display_buffer_type.h" +#include "v1_2/include/idisplay_buffer.h" + +#define HDF_LOG_TAG codec_heif_encode_test + +namespace { +using namespace std; +using namespace testing::ext; +using namespace OHOS::HDI::Codec::Image::V2_0; +using namespace OHOS::HDI::Display::Buffer::V1_2; +using namespace OHOS::HDI::Display::Composer::V1_2; + +static constexpr size_t EXTERNAL_BUFFER_SIZE = 18 * 1024 * 1024; +static constexpr size_t META_BUFFER_SIZE = 1024; + +static uint32_t id_ = 0; +static OHOS::sptr hdiHeifEncoder_ = nullptr; +static OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer* bufferMgr_ = nullptr; +static uint32_t pixelFmtNv12_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YCBCR_420_SP; +static uint32_t pixelFmtRgba_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_RGBA_8888; +static uint32_t unsupportedPixelFmt_ = OHOS::HDI::Display::Composer::V1_2::PIXEL_FMT_YUV_422_I; + +class CodecHdiHeifEncodeTest : public testing::Test { +public: + static void SetUpTestCase() + { + hdiHeifEncoder_ = ICodecImage::Get(); + bufferMgr_ = OHOS::HDI::Display::Buffer::V1_2::IDisplayBuffer::Get(); + } + static void TearDownTestCase() + { + hdiHeifEncoder_ = nullptr; + bufferMgr_ = nullptr; + } + void SetUp() + { + inputImgs_.clear(); + inputMetas_.clear(); + refs_.clear(); + output_ = AllocateSharedBuffer(EXTERNAL_BUFFER_SIZE); + filledLen_ = 0; + } + void TearDown() + { + for (auto item : inputImgs_) { + FreeSharedBuffer(item.sharedProperties); + } + for (auto item : inputMetas_) { + FreeSharedBuffer(item.data); + } + FreeSharedBuffer(output_); + } +public: + enum ImgType { + PRIMARY_IMG, + AUXILIARY_IMG, + THUMBNAIL_IMG, + GAIN_MAP, + T_MAP + }; + enum MetaType { + EXIF_DATA, + USER_DATA + }; +public: + static uint32_t GetNextId() + { + return id_++; + } + static SharedBuffer AllocateSharedBuffer(uint32_t size) + { + SharedBuffer sb = { + .fd = -1, + .filledLen = 0, + .capacity = 0 + }; + IF_TRUE_RETURN_VAL(size <= 0, sb); + int fd = AshmemCreate("ForHeifEncodeUT", size); + if (fd > 0) { + sb.fd = fd; + sb.filledLen = static_cast(size); + sb.capacity = static_cast(AshmemGetSize(fd)); + } else { + HDF_LOGE("cannot create ashmem"); + } + return sb; + } + + static void FreeSharedBuffer(SharedBuffer& sb) + { + if (sb.fd > 0) { + close(sb.fd); + } + } + + static sptr AllocateNativeBuffer(uint32_t width, uint32_t height, uint32_t pixelFmt) + { + uint64_t usage = OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_READ | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_CPU_WRITE | + OHOS::HDI::Display::Composer::V1_2::HBM_USE_MEM_DMA; + AllocInfo alloc = { + .width = width, + .height = height, + .usage = usage, + .format = pixelFmt + }; + BufferHandle *handle = nullptr; + int32_t ret = bufferMgr_->AllocMem(alloc, handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("failed to alloc buffer, err [%{public}d] !", ret); + return nullptr; + } + sptr imgBuffer = new NativeBuffer(handle); + return imgBuffer; + } + static ImageItem CreateImageItem(ImgType imageType, uint32_t pixelFmt, bool needAllocPixelBuffer = true) + { + static constexpr uint32_t ENCODE_QUALITY = 85; + static constexpr uint32_t PIXEL_WIDTH = 1920; + static constexpr uint32_t PIXEL_HEIGHT = 1080; + ImageItem item = { + .itemName = "", + .id = GetNextId(), + .pixelBuffer = nullptr, + .isPrimary = (imageType == PRIMARY_IMG), + .isHidden = (imageType != PRIMARY_IMG), + .compressType = "hevc", + .quality = ENCODE_QUALITY, + .liteProperties = {}, + .sharedProperties = AllocateSharedBuffer(0) + }; + if (needAllocPixelBuffer && (imageType != T_MAP)) { + item.pixelBuffer = AllocateNativeBuffer(PIXEL_WIDTH, PIXEL_HEIGHT, pixelFmt); + } + return item; + } + static MetaItem CreateMetaItem(MetaType type) + { + MetaItem item = { + .itemName = (type == USER_DATA) ? "userdata" : "exif", + .id = GetNextId(), + .data = AllocateSharedBuffer(META_BUFFER_SIZE), + .properties = {} + }; + if (type == USER_DATA) { + bool useCompress = true; + PropWriter pw; + (void)pw.AddData(USER_DATA_DO_COMPRESS, useCompress); + (void)pw.Finalize(item.properties); + } + return item; + } + static bool SetValidNclxColor(ImageItem& item) + { + PropWriter pw; + ColorType clrType = NCLX; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_TYPE, clrType), false); + ColourInfo clrInfo = { + .colourPrimaries = 2, + .transferCharacteristics = 2, + .matrixCoefficients = 2, + .fullRangeFlag = false + }; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_INFO, clrInfo), false); + return pw.Finalize(item.liteProperties); + } + static bool SetColorTypeOnly(ImageItem& item, ColorType clrType) + { + PropWriter pw; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_TYPE, clrType), false); + return pw.Finalize(item.liteProperties); + } + static bool SetInvalidRiccColor(ImageItem& item) + { + PropWriter pw; + ColorType clrType = RICC; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_TYPE, clrType), false); + IF_TRUE_RETURN_VAL(!pw.Finalize(item.liteProperties), false); + PropertyType propType = ICC_PROFILE; + size_t bufferSize = sizeof(propType); + item.sharedProperties = AllocateSharedBuffer(bufferSize); + IF_TRUE_RETURN_VAL(item.sharedProperties.fd < 0, false); + void *addr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, item.sharedProperties.fd, 0); + if (addr == nullptr) { + close(item.sharedProperties.fd); + item.sharedProperties.fd = -1; + return false; + } + errno_t ret = memcpy_s(addr, bufferSize, reinterpret_cast(&propType), bufferSize); + (void)munmap(addr, bufferSize); + return (ret == EOK); + } + static bool SetInvalidNclxColor(ImageItem& item) + { + PropWriter pw; + ColourInfo clrInfo = { + .colourPrimaries = 2, + .transferCharacteristics = 2, + .matrixCoefficients = 2, + .fullRangeFlag = false + }; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_INFO, clrInfo), false); + return pw.Finalize(item.liteProperties); + } + static bool SetPropeForTmap(ImageItem& item) + { + PropWriter pw; + ColorType clrType = NCLX; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_TYPE, clrType), false); + ColourInfo clrInfo = { + .colourPrimaries = 2, + .transferCharacteristics = 2, + .matrixCoefficients = 2, + .fullRangeFlag = false + }; + IF_TRUE_RETURN_VAL(!pw.AddData(COLOR_INFO, clrInfo), false); + ToneMapMetadata tmapMeta; + static constexpr uint8_t MULTI_CHANNEL = 3; + tmapMeta.channelCnt = MULTI_CHANNEL; + tmapMeta.useBaseColorSpace = true; + tmapMeta.baseHdrHeadroom = {12, 23}; + tmapMeta.alternateHdrHeadroom = {36, 62}; + tmapMeta.channels1 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + tmapMeta.channels2 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + tmapMeta.channels3 = { + .gainMapMin = {5, 21}, + .gainMapMax = {5, 7}, + .gamma = {2, 7}, + .baseOffset = {1, 3}, + .alternateOffset = {1, 7} + }; + IF_TRUE_RETURN_VAL(!pw.AddData(TONE_MAP_METADATA, tmapMeta), false); + return pw.Finalize(item.liteProperties); + } +public: + vector inputImgs_; + vector inputMetas_; + vector refs_; + SharedBuffer output_; + uint32_t filledLen_; +}; + +// [OK] primary image +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_001, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_EQ(ret, HDF_SUCCESS); + ASSERT_TRUE(filledLen_ > 0); +} + +// [OK] primary image + auxl image + thumnail + userdata +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_002, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(thumImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = auxlImageItem.id, + .to = { primaryImageItem.id } + }); + refs_.emplace_back(ItemRef { + .type = THMB, + .auxType = "", + .from = thumImageItem.id, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + inputImgs_.emplace_back(thumImageItem); + MetaItem metaUserData = CreateMetaItem(USER_DATA); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = { primaryImageItem.id } + }); + inputMetas_.emplace_back(metaUserData); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_EQ(ret, HDF_SUCCESS); + ASSERT_TRUE(filledLen_ > 0); +} + +// [FAIL] auxl image only +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_003, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + inputImgs_.emplace_back(auxlImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + (image.pixelBuffer == nullptr) +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_004, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_, false); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + unsupported pixelFmt in image.pixelBuffer +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_005, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + (COLOR_TYPE == NCLX) + COLOR_INFO not configured +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_006, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false); + ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, NCLX)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + (COLOR_TYPE == RICC) + ICC_PROFILE not configured +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_007, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false); + ASSERT_TRUE(SetColorTypeOnly(primaryImageItem, RICC)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + (COLOR_TYPE == RICC) + SharedBuffer that store ICC_PROFILE is not properly filled +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_008, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false); + ASSERT_TRUE(SetInvalidRiccColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] primary image + COLOR_INFO is configured + COLOR_TYPE not configured +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_009, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, unsupportedPixelFmt_, false); + ASSERT_TRUE(SetInvalidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] auxl image is not related to primary image +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_010, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(thumImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = auxlImageItem.id, + .to = { thumImageItem.id } + }); + refs_.emplace_back(ItemRef { + .type = THMB, + .auxType = "", + .from = thumImageItem.id, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + inputImgs_.emplace_back(thumImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] auxl image is configured in refs, but not included in inputImgs +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_011, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = 100, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] auxl image is related to an image that is not included in inputImgs +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_012, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = auxlImageItem.id, + .to = { 100 } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] auxl image is related to more than one images +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_013, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(thumImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = auxlImageItem.id, + .to = { primaryImageItem.id, thumImageItem.id } + }); + refs_.emplace_back(ItemRef { + .type = THMB, + .auxType = "", + .from = thumImageItem.id, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + inputImgs_.emplace_back(thumImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] userdata meta is not related to primary image +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_014, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); + refs_.emplace_back(ItemRef { + .type = AUXL, + .auxType = "", + .from = auxlImageItem.id, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(auxlImageItem); + MetaItem metaUserData = CreateMetaItem(USER_DATA); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = { auxlImageItem.id } + }); + inputMetas_.emplace_back(metaUserData); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] userdata meta is configured in refs, but not included in inputMetas +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_015, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + MetaItem metaUserData = CreateMetaItem(USER_DATA); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = { primaryImageItem.id } + }); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] userdata meta is related to an image that is not included in inputImgs +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_016, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + MetaItem metaUserData = CreateMetaItem(USER_DATA); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = { 100 } + }); + inputMetas_.emplace_back(metaUserData); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] userdata meta is related to more than one images +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_017, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + MetaItem metaUserData = CreateMetaItem(USER_DATA); + refs_.emplace_back(ItemRef { + .type = CDSC, + .auxType = "", + .from = metaUserData.id, + .to = { primaryImageItem.id, 100 } + }); + inputMetas_.emplace_back(metaUserData); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] output buffer is not properly configured, fd or capacity is invalid +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_018, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + SharedBuffer errOurput = AllocateSharedBuffer(0); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] output buffer is not properly configured, capacity is too small +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_019, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + inputImgs_.emplace_back(primaryImageItem); + size_t smallSize = 128; + SharedBuffer errOurput = AllocateSharedBuffer(smallSize); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, errOurput, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [OK] primary image + gainmap image +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_020, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = tmapImageItem.id, + .to = { primaryImageItem.id, gainMapImageItem.id } + }); + inputImgs_.emplace_back(tmapImageItem); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(gainMapImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_EQ(ret, HDF_SUCCESS); + ASSERT_TRUE(filledLen_ > 0); +} + +// [FAIL] Tmap image is configured in refs, but not included in inputImgs +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_021, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = tmapImageItem.id, + .to = { primaryImageItem.id, gainMapImageItem.id } + }); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(gainMapImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] Tmap is not related to any gainmap +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_022, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = tmapImageItem.id, + .to = { primaryImageItem.id } + }); + inputImgs_.emplace_back(tmapImageItem); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(gainMapImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] Tmap is related to two identical images +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_023, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = tmapImageItem.id, + .to = { gainMapImageItem.id, gainMapImageItem.id } + }); + inputImgs_.emplace_back(tmapImageItem); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(gainMapImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} + +// [FAIL] Tmap is related to images that are not included in inputImgs +HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_024, TestSize.Level1) +{ + ASSERT_TRUE(hdiHeifEncoder_ != nullptr); + ASSERT_TRUE(bufferMgr_ != nullptr); + ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); + ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); + ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); + ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); + refs_.emplace_back(ItemRef { + .type = DIMG, + .auxType = "", + .from = tmapImageItem.id, + .to = { gainMapImageItem.id, 100 } + }); + inputImgs_.emplace_back(tmapImageItem); + inputImgs_.emplace_back(primaryImageItem); + inputImgs_.emplace_back(gainMapImageItem); + int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_EQ(filledLen_, 0); +} +} \ No newline at end of file diff --git a/codec/test/unittest/hdi_image/codec_hdi_jpeg_test.cpp b/codec/test/unittest/hdi_image/codec_hdi_jpeg_test.cpp index 9645ca3887..b835fa7337 100644 --- a/codec/test/unittest/hdi_image/codec_hdi_jpeg_test.cpp +++ b/codec/test/unittest/hdi_image/codec_hdi_jpeg_test.cpp @@ -19,14 +19,14 @@ #include "v1_0/include/idisplay_buffer.h" #include "v1_0/display_composer_type.h" #include "v1_0/display_buffer_type.h" -#include "v1_0/icodec_image.h" +#include "v2_0/icodec_image.h" #define HDF_LOG_TAG codec_jpeg_test using namespace std; using namespace testing::ext; using namespace OHOS::HDI::Display::Buffer::V1_0; using namespace OHOS::HDI::Display::Composer::V1_0; -using namespace OHOS::HDI::Codec::Image::V1_0; +using namespace OHOS::HDI::Codec::Image::V2_0; namespace { constexpr int32_t WIDTH = 640; constexpr int32_t HEIGHT = 480; diff --git a/codec/test/unittest/hdi_image/test_helper.h b/codec/test/unittest/hdi_image/test_helper.h new file mode 100644 index 0000000000..625e46f43e --- /dev/null +++ b/codec/test/unittest/hdi_image/test_helper.h @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_CODEC_IMAGE_V2_0_HEIF_ENCODE_TEST_HELPER +#define OHOS_HDI_CODEC_IMAGE_V2_0_HEIF_ENCODE_TEST_HELPER + +#include +#include +#include +#include "hdf_log.h" +#include "ashmem.h" +#include "v2_0/icodec_image.h" + +#define IF_TRUE_RETURN_VAL(cond, val) \ + do { \ + if (cond) { \ + return val; \ + } \ + } while (0) + +class PropWriter { +public: + PropWriter() = default; + ~PropWriter() + { + for (auto iter = data_.begin(); iter != data_.end(); ++iter) { + delete [] iter->data; + } + data_.clear(); + } + template + bool AddData(OHOS::HDI::Codec::Image::V2_0::PropertyType key, T& value) + { + std::size_t keySize = sizeof(key); + std::size_t valueSize = sizeof(value); + std::size_t dataSize = keySize + valueSize; + uint8_t* p = new uint8_t[dataSize]; + IF_TRUE_RETURN_VAL(p == nullptr, false); + data_.emplace_back(DataBlock { + .data = p, + .len = dataSize + }); + totalSize_ += dataSize; + errno_t ret = memset_s(p, dataSize, 0, dataSize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + ret = memcpy_s(p, dataSize, reinterpret_cast(&key), keySize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + ret = memcpy_s(p + keySize, valueSize, reinterpret_cast(&value), valueSize); + IF_TRUE_RETURN_VAL(ret != EOK, false); + return true; + } + bool Finalize(std::vector& dst) + { + dst.clear(); + dst.resize(totalSize_); + uint8_t* dstStart = reinterpret_cast(dst.data()); + size_t offset = 0; + errno_t ret = EOK; + for (auto iter = data_.begin(); (iter != data_.end()) && (ret == EOK); ++iter) { + ret = memcpy_s(dstStart + offset, iter->len, iter->data, iter->len); + offset += iter->len; + } + return (ret == EOK); + } +private: + struct DataBlock { + uint8_t* data = nullptr; + std::size_t len = 0; + }; +private: + std::list data_; + std::size_t totalSize_ = 0; +}; +#endif // OHOS_HDI_CODEC_IMAGE_V2_0_HEIF_ENCODE_TEST_HELPER \ No newline at end of file -- Gitee From d16dc8659b91ba0b9c40c3de71632d0cc5dd9cd9 Mon Sep 17 00:00:00 2001 From: hwyml Date: Wed, 17 Jul 2024 10:46:20 +0800 Subject: [PATCH 0108/1485] add clear halt Signed-off-by: hwyml Change-Id: Iefd750cd4dd45b9c8286d52bf3c9a48a6cc0162b --- usb/hdi_service/include/usb_impl.h | 1 + usb/hdi_service/src/usb_impl.cpp | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index b5ce6232de..b6966d3cb2 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -92,6 +92,7 @@ public: int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr &ashmem) override; int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr &ashmem) override; int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe) override; + int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe) override; static int32_t UsbdRequestSyncReleaseList(HostDevice *port); static int32_t UsbdRequestASyncReleaseList(HostDevice *port); diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 1d9dc9e08b..18344c6ad8 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -2195,6 +2195,24 @@ int32_t UsbImpl::BulkCancel(const UsbDev &dev, const UsbPipe &pipe) return HDF_SUCCESS; } +int32_t UsbImpl::ClearHalt(const UsbDev &dev, const UsbPipe &pipe) +{ + HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); + if (port == nullptr) { + HDF_LOGE("%{public}s:FindDevFromService failed", __func__); + return HDF_DEV_ERR_NO_DEVICE; + } + if (pipe.intfId >= USB_MAX_INTERFACES) { + HDF_LOGE("%{public}s:interfaceId larger then max num", __func__); + return HDF_ERR_INVALID_PARAM; + } + int32_t ret = UsbClearInterfaceHalt(port->devHandle[pipe.intfId], pipe.endpointId); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:ClearHalt error ret:%{public}d", __func__, ret); + } + return ret; +} + int32_t UsbImpl::GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool &unactivated) { HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); -- Gitee From 3d4a882e5f7c04b2929d92b55b43f210a80cf632 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 17:05:23 +0800 Subject: [PATCH 0109/1485] =?UTF-8?q?=E7=A8=B3=E5=AE=9A=E6=80=A7=E5=8A=A0?= =?UTF-8?q?=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/hostapd/client/src/hostapd_client.c | 2 +- .../interfaces/hdi_service/service_common/hdi_hostapd_hal.c | 2 +- wlan/wpa/client/src/wpa_client.c | 2 +- .../interfaces/hdi_service/service_common/hdi_wpa_common.c | 4 ++-- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/wlan/hostapd/client/src/hostapd_client.c b/wlan/hostapd/client/src/hostapd_client.c index 3150776c0a..e459f0d5c5 100644 --- a/wlan/hostapd/client/src/hostapd_client.c +++ b/wlan/hostapd/client/src/hostapd_client.c @@ -34,7 +34,7 @@ extern "C" { #define MAX_CALL_BACK_COUNT 10 static struct HostapdCallbackEvent *g_hostapdCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; -static pthread_mutex_t g_hostapdCallbackMutex; +static pthread_mutex_t g_hostapdCallbackMutex =; int32_t HostapdRegisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName) { diff --git a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c index b868ea32d0..8a184f1556 100644 --- a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c +++ b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c @@ -78,7 +78,7 @@ static char g_apIfaceName[IFACENAME_LEN]; static char g_apCfgName[CFGNAME_LEN]; #endif -static pthread_mutex_t g_mutex; +static pthread_mutex_t g_mutex =; int InitCfg(const char *ifaceName) { diff --git a/wlan/wpa/client/src/wpa_client.c b/wlan/wpa/client/src/wpa_client.c index c32ce54b7f..70fe0b3008 100644 --- a/wlan/wpa/client/src/wpa_client.c +++ b/wlan/wpa/client/src/wpa_client.c @@ -33,7 +33,7 @@ extern "C" { #define MAX_CALL_BACK_COUNT 10 static struct WpaCallbackEvent *g_wpaCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; -static pthread_mutex_t g_wpaCallbackMutex; +static pthread_mutex_t g_wpaCallbackMutex =; int32_t WpaRegisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index 1f118d7675..bacd1e6c4c 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -27,8 +27,8 @@ #define DEC_MAX_SCOPE 10 #define WPA_CMD_RETURN_TIMEOUT (-2) -static pthread_mutex_t g_mutexSta; -static pthread_mutex_t g_mutexP2p; +static pthread_mutex_t g_mutexSta =; +static pthread_mutex_t g_mutexP2p =; static pthread_mutex_t g_mutexChba; static pthread_mutex_t g_mutexCommon; static pthread_mutex_t g_mutexWpa; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index de72f1c2cc..83efaef70f 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -62,7 +62,7 @@ static const int MAX_IFACE_LEN = 6; #define WPA_CTRL_OPEN_IFNAME "@abstract:"CONFIG_ROOR_DIR"/sockets/wpa/wlan0" static WifiWpaInterface *g_wpaInterface = NULL; -static pthread_mutex_t g_mutex; +static pthread_mutex_t g_mutex =; static int WpaCliConnect(WifiWpaInterface *p) { -- Gitee From a0feb5e3d8338826ecfc9fc29db6ae19d9d1a242 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 09:37:51 +0000 Subject: [PATCH 0110/1485] update wlan/hostapd/client/src/hostapd_client.c. Signed-off-by: xionglei --- wlan/hostapd/client/src/hostapd_client.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/hostapd/client/src/hostapd_client.c b/wlan/hostapd/client/src/hostapd_client.c index e459f0d5c5..8c5c73c23b 100644 --- a/wlan/hostapd/client/src/hostapd_client.c +++ b/wlan/hostapd/client/src/hostapd_client.c @@ -34,7 +34,7 @@ extern "C" { #define MAX_CALL_BACK_COUNT 10 static struct HostapdCallbackEvent *g_hostapdCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; -static pthread_mutex_t g_hostapdCallbackMutex =; +static pthread_mutex_t g_hostapdCallbackMutex = PTHREAD_MUTEX_INITIALIZER; int32_t HostapdRegisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName) { -- Gitee From 581adea8e192388d3aa8bb0341619c0b5a539af7 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 09:38:39 +0000 Subject: [PATCH 0111/1485] update wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c. Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/hdi_hostapd_hal.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c index 8a184f1556..2c9916c438 100644 --- a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c +++ b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c @@ -78,7 +78,7 @@ static char g_apIfaceName[IFACENAME_LEN]; static char g_apCfgName[CFGNAME_LEN]; #endif -static pthread_mutex_t g_mutex =; +static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; int InitCfg(const char *ifaceName) { -- Gitee From 6c22d31887961b0f1f3faa28f762a576d2de9757 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 09:39:34 +0000 Subject: [PATCH 0112/1485] update wlan/wpa/client/src/wpa_client.c. Signed-off-by: xionglei --- wlan/wpa/client/src/wpa_client.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/wpa/client/src/wpa_client.c b/wlan/wpa/client/src/wpa_client.c index 70fe0b3008..cd751377ec 100644 --- a/wlan/wpa/client/src/wpa_client.c +++ b/wlan/wpa/client/src/wpa_client.c @@ -33,7 +33,7 @@ extern "C" { #define MAX_CALL_BACK_COUNT 10 static struct WpaCallbackEvent *g_wpaCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; -static pthread_mutex_t g_wpaCallbackMutex =; +static pthread_mutex_t g_wpaCallbackMutex = PTHREAD_MUTEX_INITIALIZER; int32_t WpaRegisterEventCallback(OnReceiveFunc onRecFunc, uint32_t eventType, const char *ifName) -- Gitee From 5ed4afdaffc82f884919c1188584c406d8d37991 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 09:40:15 +0000 Subject: [PATCH 0113/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c. Signed-off-by: xionglei --- .../hdi_service/service_common/hdi_wpa_common.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index bacd1e6c4c..e8aeeebe9d 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -27,11 +27,11 @@ #define DEC_MAX_SCOPE 10 #define WPA_CMD_RETURN_TIMEOUT (-2) -static pthread_mutex_t g_mutexSta =; -static pthread_mutex_t g_mutexP2p =; -static pthread_mutex_t g_mutexChba; -static pthread_mutex_t g_mutexCommon; -static pthread_mutex_t g_mutexWpa; +static pthread_mutex_t g_mutexSta = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_mutexP2p = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_mutexChba = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_mutexCommon = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t g_mutexWpa = PTHREAD_MUTEX_INITIALIZER; int Hex2Dec(const char *str) { -- Gitee From bc6f8195c0231a4920598ced795aba6d9157e115 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 9 Aug 2024 09:40:40 +0000 Subject: [PATCH 0114/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index 83efaef70f..f3c6b1a4a3 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -62,7 +62,7 @@ static const int MAX_IFACE_LEN = 6; #define WPA_CTRL_OPEN_IFNAME "@abstract:"CONFIG_ROOR_DIR"/sockets/wpa/wlan0" static WifiWpaInterface *g_wpaInterface = NULL; -static pthread_mutex_t g_mutex =; +static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; static int WpaCliConnect(WifiWpaInterface *p) { -- Gitee From 21f6b6ff69e50f3a215637adedd04b6dac4642d2 Mon Sep 17 00:00:00 2001 From: qinjihong Date: Sat, 10 Aug 2024 09:50:38 +0800 Subject: [PATCH 0115/1485] add resetDevice Signed-off-by: qinjihong --- usb/ddk/host/include/linux_adapter.h | 2 +- usb/ddk/host/src/linux_adapter.c | 17 ++++++++- usb/ddk/host/src/usb_interface_pool.c | 41 +++++++++++++++++++++ usb/ddk/host/src/usb_raw_api_library.c | 4 +- usb/hdi_service/include/usb_impl.h | 1 + usb/hdi_service/src/usb_impl.cpp | 19 ++++++++++ usb/interfaces/ddk/host/usb_ddk_interface.h | 10 +++++ 7 files changed, 90 insertions(+), 4 deletions(-) diff --git a/usb/ddk/host/include/linux_adapter.h b/usb/ddk/host/include/linux_adapter.h index 507cd56229..63806ea18c 100644 --- a/usb/ddk/host/include/linux_adapter.h +++ b/usb/ddk/host/include/linux_adapter.h @@ -132,7 +132,7 @@ struct UsbOsAdapterOps { int32_t (*setInterfaceAltsetting)(const struct UsbDeviceHandle *devHandle, uint8_t interfaceNumber, uint8_t altsetting); int32_t (*clearHalt)(const struct UsbDeviceHandle *devHandle, unsigned int endpoint); - int32_t (*resetDevice)(const struct UsbDeviceHandle *devHandle); + int32_t (*resetDevice)(struct UsbDeviceHandle *devHandle); struct UsbHostRequest *(*allocRequest)(const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len); struct UsbHostRequest *(*allocRequestByMmap)(const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len); int32_t (*freeRequest)(struct UsbHostRequest *request); diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index a258bcdaba..59eaff857e 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -1245,7 +1245,7 @@ static int32_t AdapterClearHalt(const struct UsbDeviceHandle *handle, unsigned i return HDF_SUCCESS; } -static int32_t AdapterResetDevice(const struct UsbDeviceHandle *handle) +static int32_t AdapterResetDevice(struct UsbDeviceHandle *handle) { int32_t ret; uint8_t i; @@ -1267,7 +1267,20 @@ static int32_t AdapterResetDevice(const struct UsbDeviceHandle *handle) return HDF_FAILURE; } - return HDF_SUCCESS; + for (i = 0;i < USB_MAXINTERFACES; i++) { + if (!(handle->claimedInterfaces & (1UL << i))) + { + continue; + } + ret = AdapterDetachKernelDriverAndClaim(handle, i); + if (ret) { + HDF_LOGE("%{public}s:%{public}d failed to re-claim interface %{public}u after reset errno=%{public}d", __func__, __LINE__, i , errno); + handle->claimedInterfaces &= ~(1UL << i); + break; + } + } + + return ret; } static struct UsbHostRequest *AdapterAllocRequest(const struct UsbDeviceHandle *handle, int32_t isoPackets, size_t len) diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index 3c035471d5..f2d9104d29 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1304,6 +1304,47 @@ OUT: return NULL; } +UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) +{ + HDF_STATUS ret; + if (interfaceObj == NULL) { + HDF_LOGE("%{public}s:%{public}d interfaceObj is null", __func__, __LINE__); + return NULL; + } + + struct UsbSdkInterface *interfaceSdk = (struct UsbSdkInterface *)interfaceObj; + if (interfaceSdk->session == NULL || interfaceSdk->status == USB_INTERFACE_STATUS_REMOVE) { + HDF_LOGE("%{public}s:%{public}d interface->status = %{public}d is error", + __func__, __LINE__, interfaceSdk->status); + return NULL; + } + + struct UsbPoolQueryPara poolQueryPara; + poolQueryPara.type = USB_POOL_OBJECT_ID_TYPE; + poolQueryPara.objectId = interfaceSdk->parentObjectId; + struct UsbInterfacePool *interfacePool = IfFindInterfacePool(interfaceSdk->session, poolQueryPara, false); + if (interfacePool == NULL || interfacePool->device == NULL || interfacePool->device->devHandle == NULL) { + HDF_LOGE("%{public}s:%{public}d interfacePool or interfacePool->device is null", __func__, __LINE__); + return NULL; + } + + ret = RawResetDevice(interfacePool->device->devHandle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{piblic}s:%{public}d RawResetDevice failed, ret = %{public}d", __func__, __LINE__, ret); + return NULL; + } + + struct UsbInterfaceHandleEntity *ifaceHdl = RawUsbMemCalloc(sizeof(struct UsbInterfaceHandleEntity)); + if (ifaceHdl == NULL) { + HDF_LOGE("%{public}s:%{public}d RawUsbMemCalloc failed", __func__, __LINE__); + return NULL; + } + ifaceHdl->devHandle = interfacePool->device->devHandle; + ifaceHdl->interfaceIndex = interfaceSdk->interface.info.interfaceIndex; + + return (UsbInterfaceHandle *)ifaceHdl; +} + int32_t GetInterfaceByHandle(const UsbInterfaceHandle *interfaceHandle, struct UsbInterface **interface) { if (interfaceHandle == NULL) { diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 9321fb2358..26fb5e1ce2 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1456,7 +1456,9 @@ int32_t RawResetDevice(const struct UsbDeviceHandle *devHandle) return HDF_ERR_NOT_SUPPORT; } - return osAdapterOps->resetDevice(devHandle); + struct UsbDeviceHandle *constDevHandle = (struct UsbDeviceHandle *)devHandle; + + return osAdapterOps->resetDevice(constDevHandle); } int32_t RawSubmitRequest(const struct UsbHostRequest *request) diff --git a/usb/hdi_service/include/usb_impl.h b/usb/hdi_service/include/usb_impl.h index b5ce6232de..e25f0dd635 100644 --- a/usb/hdi_service/include/usb_impl.h +++ b/usb/hdi_service/include/usb_impl.h @@ -45,6 +45,7 @@ public: ~UsbImpl() override; int32_t OpenDevice(const UsbDev &dev) override; int32_t CloseDevice(const UsbDev &dev) override; + int32_t ResetDevice(const UsbDev &dev) override; int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector &decriptor) override; int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector &decriptor) override; int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector &decriptor) override; diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 1d9dc9e08b..b4b12bb723 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1117,6 +1117,25 @@ int32_t UsbImpl::CloseDevice(const UsbDev &dev) return HDF_SUCCESS; } +int32_t UsbImpl::ResetDevice(const UsbDev &dev) +{ + HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); + if (port == nullptr) { + HDF_LOGE("%{public}s:FindDevFromService failed", __func__); + return HDF_DEV_ERR_NO_DEVICE; + } + if (port->ctrDevHandle == nullptr && port->ctrIface != nullptr) { + HDF_LOGD("%{public}s:start resetDevice, busNum: %{public}d, devAddr: %{public}d ", + __func__, dev.busNum, dev.devAddr); + port->ctrDevHandle = UsbResetDevice(port->ctrIface); + if (port->ctrDevHandle == nullptr) { + HDF_LOGE("%{public}s:UsbResetDevice failed", __func__); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + int32_t UsbImpl::GetDeviceDescriptor(const UsbDev &dev, std::vector &descriptor) { HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); diff --git a/usb/interfaces/ddk/host/usb_ddk_interface.h b/usb/interfaces/ddk/host/usb_ddk_interface.h index 002eb27259..3dc8997e7b 100644 --- a/usb/interfaces/ddk/host/usb_ddk_interface.h +++ b/usb/interfaces/ddk/host/usb_ddk_interface.h @@ -404,6 +404,16 @@ UsbInterfaceHandle *UsbOpenInterface(const struct UsbInterface *interfaceObj); */ int32_t UsbCloseInterface(const UsbInterfaceHandle *interfaceHandle, bool isCtrInterface); +/** + * @brief Reset a USB interface object. + * + * @param interfaceObj Indicates the pointer to the USB interface object to reset. + * + * @return Returns 0 if the operation is successful; returns a negative value defined in {@link HDF_STATUS} + * otherwise. + */ +UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj); + /** * @brief Sets the optional configuration. * -- Gitee From 898f894ce95060aeed591a0cbc4a4d3bb943c0e5 Mon Sep 17 00:00:00 2001 From: w30042960 Date: Sat, 10 Aug 2024 11:01:29 +0800 Subject: [PATCH 0116/1485] modify gn Signed-off-by: w30042960 --- .../v1_0/test/unittest/audio_adapter_interface/BUILD.gn | 8 +++----- .../v1_0/test/unittest/audio_capture_interface/BUILD.gn | 8 +++----- .../v1_0/test/unittest/audio_manager_interface/BUILD.gn | 8 +++----- .../v1_0/test/unittest/audio_render_interface/BUILD.gn | 3 +-- .../hdi_service/audio_ext/v1_0/test/unittest/BUILD.gn | 8 +++----- .../test/unittest/common/dcamera_device/BUILD.gn | 2 -- .../test/unittest/common/dstream_operator/BUILD.gn | 2 -- 7 files changed, 13 insertions(+), 26 deletions(-) diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/BUILD.gn index 0f4d1913cb..d8701ac217 100644 --- a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/BUILD.gn @@ -39,16 +39,14 @@ ohos_unittest("HDIServiceAudioAdapterTest") { configs = [ ":module_private_config" ] - public_deps = [ - "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0", - "//third_party/googletest:gmock", - "//third_party/googletest:gtest_main", - ] + public_deps = + [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0" ] external_deps = [ "c_utils:utils", "drivers_interface_distributed_audio:libdaudio_stub_1.0", "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", "hilog:libhilog", "ipc:ipc_core", ] diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_interface/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_interface/BUILD.gn index 4bd6552ad7..bed1ee5159 100644 --- a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_interface/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_interface/BUILD.gn @@ -38,16 +38,14 @@ ohos_unittest("HDIServiceCaptureTest") { configs = [ ":module_private_config" ] - public_deps = [ - "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0", - "//third_party/googletest:gmock", - "//third_party/googletest:gtest_main", - ] + public_deps = + [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0" ] external_deps = [ "c_utils:utils", "drivers_interface_distributed_audio:libdaudio_stub_1.0", "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", "hilog:libhilog", "ipc:ipc_core", ] diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_manager_interface/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_manager_interface/BUILD.gn index ed82246534..7defa0350a 100644 --- a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_manager_interface/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_manager_interface/BUILD.gn @@ -38,17 +38,15 @@ ohos_unittest("HDIServiceManagerTest") { configs = [ ":module_private_config" ] - public_deps = [ - "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0", - "//third_party/googletest:gmock", - "//third_party/googletest:gtest_main", - ] + public_deps = + [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0" ] external_deps = [ "cJSON:cjson", "c_utils:utils", "drivers_interface_distributed_audio:libdaudio_stub_1.0", "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", "hdf_core:libhdf_host", "hilog:libhilog", "ipc:ipc_core", diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_interface/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_interface/BUILD.gn index 43b79a854a..c8e41689a6 100644 --- a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_interface/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_interface/BUILD.gn @@ -41,14 +41,13 @@ ohos_unittest("HDIServiceRenderTest") { public_deps = [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0", "${hdf_service_path}/hdi_service/common:libdaudio_hdf_utils", - "//third_party/googletest:gmock", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", "drivers_interface_distributed_audio:libdaudio_stub_1.0", "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", "hilog:libhilog", "ipc:ipc_core", ] diff --git a/distributed_audio/hdi_service/audio_ext/v1_0/test/unittest/BUILD.gn b/distributed_audio/hdi_service/audio_ext/v1_0/test/unittest/BUILD.gn index 22595b48d9..78ec756187 100644 --- a/distributed_audio/hdi_service/audio_ext/v1_0/test/unittest/BUILD.gn +++ b/distributed_audio/hdi_service/audio_ext/v1_0/test/unittest/BUILD.gn @@ -38,16 +38,14 @@ ohos_unittest("HDIServiceDaudioExtTest") { configs = [ ":module_private_config" ] - public_deps = [ - "${hdf_ser_aud_ext_path}:libdaudio_manager_daudio_ext_service_2.0", - "//third_party/googletest:gmock", - "//third_party/googletest:gtest_main", - ] + public_deps = + [ "${hdf_ser_aud_ext_path}:libdaudio_manager_daudio_ext_service_2.0" ] external_deps = [ "c_utils:utils", "drivers_interface_distributed_audio:libdaudio_stub_1.0", "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", "hdf_core:libhdf_host", "ipc:ipc_core", ] diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn index 4b4543c0dc..42ca61307b 100644 --- a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn @@ -30,8 +30,6 @@ config("module_private_config") { "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", - "${camera_hdf_path}/camera/interfaces/include", - "${camera_hdf_path}/camera/interfaces/hdi_ipc", ] } diff --git a/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn index 04bc2d428f..5198d426ee 100644 --- a/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn +++ b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn @@ -31,8 +31,6 @@ config("module_private_config") { "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", - "${camera_hdf_path}/camera/interfaces/include", - "${camera_hdf_path}/camera/interfaces/hdi_ipc", ] } -- Gitee From 3d075a695dbd271668e53afa5d3132ff074fd444 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Sat, 10 Aug 2024 06:47:56 +0000 Subject: [PATCH 0117/1485] update code from codecheck MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/src/linux_adapter.c | 7 ++++--- usb/ddk/host/src/usb_interface_pool.c | 4 ++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 59eaff857e..405bb1696d 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -1269,14 +1269,15 @@ static int32_t AdapterResetDevice(struct UsbDeviceHandle *handle) for (i = 0;i < USB_MAXINTERFACES; i++) { if (!(handle->claimedInterfaces & (1UL << i))) - { + { continue; } ret = AdapterDetachKernelDriverAndClaim(handle, i); if (ret) { - HDF_LOGE("%{public}s:%{public}d failed to re-claim interface %{public}u after reset errno=%{public}d", __func__, __LINE__, i , errno); + HDF_LOGE("%{public}s:%{public}d failed to re-claim interface %{public}u after reset errno=%{public}d", + __func__, __LINE__, i, errno); handle->claimedInterfaces &= ~(1UL << i); - break; + break; } } diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index f2d9104d29..e413895361 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1315,7 +1315,7 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) struct UsbSdkInterface *interfaceSdk = (struct UsbSdkInterface *)interfaceObj; if (interfaceSdk->session == NULL || interfaceSdk->status == USB_INTERFACE_STATUS_REMOVE) { HDF_LOGE("%{public}s:%{public}d interface->status = %{public}d is error", - __func__, __LINE__, interfaceSdk->status); + __func__, __LINE__, interfaceSdk->status); return NULL; } @@ -1337,7 +1337,7 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) struct UsbInterfaceHandleEntity *ifaceHdl = RawUsbMemCalloc(sizeof(struct UsbInterfaceHandleEntity)); if (ifaceHdl == NULL) { HDF_LOGE("%{public}s:%{public}d RawUsbMemCalloc failed", __func__, __LINE__); - return NULL; + return NULL; } ifaceHdl->devHandle = interfacePool->device->devHandle; ifaceHdl->interfaceIndex = interfaceSdk->interface.info.interfaceIndex; -- Gitee From eb7e81523dff23bffd23998278d8a78c7ab7f8ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Sat, 10 Aug 2024 08:15:24 +0000 Subject: [PATCH 0118/1485] update by codecheck MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/include/usb_interface_pool.h | 1 + usb/ddk/host/src/linux_adapter.c | 3 +-- usb/ddk/host/src/usb_interface_pool.c | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/usb/ddk/host/include/usb_interface_pool.h b/usb/ddk/host/include/usb_interface_pool.h index 122cbf4b46..a2c7c29df3 100644 --- a/usb/ddk/host/include/usb_interface_pool.h +++ b/usb/ddk/host/include/usb_interface_pool.h @@ -113,6 +113,7 @@ struct UsbIfRequest { bool isSyncReq; }__attribute__((aligned(4))); +UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj); int32_t UsbIfCreatPipeObj(const struct UsbSdkInterface *interfaceObj, struct UsbPipe **pipeObj); int32_t UsbIfCreatInterfaceObj(const struct UsbInterfacePool *interfacePool, struct UsbSdkInterface **interfaceObj); HDF_STATUS UsbIfDestroyInterfaceObj( diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 405bb1696d..245e497330 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -1268,8 +1268,7 @@ static int32_t AdapterResetDevice(struct UsbDeviceHandle *handle) } for (i = 0;i < USB_MAXINTERFACES; i++) { - if (!(handle->claimedInterfaces & (1UL << i))) - { + if (!(handle->claimedInterfaces & (1UL << i))) { continue; } ret = AdapterDetachKernelDriverAndClaim(handle, i); diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index e413895361..c35ddaf77a 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1315,7 +1315,7 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) struct UsbSdkInterface *interfaceSdk = (struct UsbSdkInterface *)interfaceObj; if (interfaceSdk->session == NULL || interfaceSdk->status == USB_INTERFACE_STATUS_REMOVE) { HDF_LOGE("%{public}s:%{public}d interface->status = %{public}d is error", - __func__, __LINE__, interfaceSdk->status); + __func__, __LINE__, interfaceSdk->status); return NULL; } @@ -1331,7 +1331,7 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) ret = RawResetDevice(interfacePool->device->devHandle); if (ret != HDF_SUCCESS) { HDF_LOGE("%{piblic}s:%{public}d RawResetDevice failed, ret = %{public}d", __func__, __LINE__, ret); - return NULL; + return NULL; } struct UsbInterfaceHandleEntity *ifaceHdl = RawUsbMemCalloc(sizeof(struct UsbInterfaceHandleEntity)); -- Gitee From af67fbed6559d58e9db93bbeb7790bda0e4ec64d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Sat, 10 Aug 2024 08:46:11 +0000 Subject: [PATCH 0119/1485] fix codecheck MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/src/usb_interface_pool.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index c35ddaf77a..0af31ec310 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1309,14 +1309,14 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) HDF_STATUS ret; if (interfaceObj == NULL) { HDF_LOGE("%{public}s:%{public}d interfaceObj is null", __func__, __LINE__); - return NULL; + return NULL; } struct UsbSdkInterface *interfaceSdk = (struct UsbSdkInterface *)interfaceObj; if (interfaceSdk->session == NULL || interfaceSdk->status == USB_INTERFACE_STATUS_REMOVE) { HDF_LOGE("%{public}s:%{public}d interface->status = %{public}d is error", __func__, __LINE__, interfaceSdk->status); - return NULL; + return NULL; } struct UsbPoolQueryPara poolQueryPara; @@ -1325,7 +1325,7 @@ UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj) struct UsbInterfacePool *interfacePool = IfFindInterfacePool(interfaceSdk->session, poolQueryPara, false); if (interfacePool == NULL || interfacePool->device == NULL || interfacePool->device->devHandle == NULL) { HDF_LOGE("%{public}s:%{public}d interfacePool or interfacePool->device is null", __func__, __LINE__); - return NULL; + return NULL; } ret = RawResetDevice(interfacePool->device->devHandle); -- Gitee From eb6fc02f34b807e99edf8a7d8dbda40c92e8ee51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Sat, 10 Aug 2024 08:55:17 +0000 Subject: [PATCH 0120/1485] update usb_interface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/ddk/host/include/usb_interface_pool.h | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/ddk/host/include/usb_interface_pool.h b/usb/ddk/host/include/usb_interface_pool.h index a2c7c29df3..122cbf4b46 100644 --- a/usb/ddk/host/include/usb_interface_pool.h +++ b/usb/ddk/host/include/usb_interface_pool.h @@ -113,7 +113,6 @@ struct UsbIfRequest { bool isSyncReq; }__attribute__((aligned(4))); -UsbInterfaceHandle *UsbResetDevice(const struct UsbInterface *interfaceObj); int32_t UsbIfCreatPipeObj(const struct UsbSdkInterface *interfaceObj, struct UsbPipe **pipeObj); int32_t UsbIfCreatInterfaceObj(const struct UsbInterfacePool *interfacePool, struct UsbSdkInterface **interfaceObj); HDF_STATUS UsbIfDestroyInterfaceObj( -- Gitee From 88e30f5a4c5b589e14b4cbfaeeef6cb6da49ab31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 10 Aug 2024 17:10:19 +0800 Subject: [PATCH 0121/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../sample/tools/gen_cr_by_pr/gen_cr_by_pr.py | 206 ++++++++++++++++++ 1 file changed, 206 insertions(+) create mode 100644 audio/test/sample/tools/gen_cr_by_pr/gen_cr_by_pr.py diff --git a/audio/test/sample/tools/gen_cr_by_pr/gen_cr_by_pr.py b/audio/test/sample/tools/gen_cr_by_pr/gen_cr_by_pr.py new file mode 100644 index 0000000000..768a2756d3 --- /dev/null +++ b/audio/test/sample/tools/gen_cr_by_pr/gen_cr_by_pr.py @@ -0,0 +1,206 @@ +# +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import os +import sys +import subprocess +import sqlite3 +import threading +import time +import re +import shutil +import uuid +import random +import json +import sqlite3 +import datetime +import inspect + +# from git import Repo + +# Enter your username and password +username = '********' +password = '********' +# Enter your prs +prs = [ + "https://gitee.com/openharmony/drivers_interface/pulls/1152", + "https://gitee.com/openharmony/drivers_peripheral/pulls/6193", + "https://gitee.com/openharmony/multimedia_camera_framework/pulls/1750", + "https://gitee.com/openharmony/graphic_graphic_2d/pulls/13515", + "https://gitee.com/openharmony/multimedia_image_framework/pulls/2281", + "https://gitee.com/openharmony/xts_hats/pulls/1212", + "https://gitee.com/openharmony/powermgr_battery_manager/pulls/579", + "https://gitee.com/openharmony/distributedhardware_distributed_camera/pulls/630", +] +if os.name == 'nt': + mix = "\\" +else: + mix = "/" +print(f'mix={mix}') +code_root = "code" +repo_name_for_code_map = { + "drivers_peripheral": f'{code_root}{mix}drivers{mix}peripheral', + "drivers_interface": f'{code_root}{mix}drivers{mix}interface', + "multimedia_camera_framework": f'{code_root}{mix}foundation{mix}multimedia{mix}camera_framework', + "graphic_graphic_2d": f'{code_root}{mix}foundation{mix}graphic{mix}graphic_2d', + "multimedia_image_framework": f'{code_root}{mix}foundation{mix}multimedia{mix}image_framework', + "xts_hats": f'{code_root}{mix}test{mix}xts{mix}hats', + "powermgr_battery_manager": f'{code_root}{mix}base{mix}powermgr{mix}battery_manager', + "distributedhardware_distributed_camera": f'{code_root}{mix}foundation{mix}distributedhardware{mix}distributed_camera', +} + + +# Run a cmd command, When using it, change the parameter to shell=True +# Please see this note +# Please see this note +# Please see this note +def run_cmd(cmd, path_to_work_in='.'): + __func__ = inspect.currentframe().f_code.co_name + print(f"{__func__}: {cmd}") + output = "" + try: + output = subprocess.run(cmd, cwd=path_to_work_in, shell=False, stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL, + text=True, + check=True).stdout + except Exception as e: + print(f"run_cmdʧ") + print(f"{__func__}: result:{str(output)}") + return output + + +# Initialize the environment conditions for accessing git +def init_environment(): + init_cmds = [ + f"export https_proxy=http://{username}:{password}@proxyhk.huawei.com:8080", + f"export http_proxy=http://{username}:{password}@proxyhk.huawei.com:8080", + f"export https_proxy=http://{username}:{password}@proxy.huawei.com:8080", + f"export http_proxy=http://{username}:{password}@proxy.huawei.com:8080", + f"git config --global https.proxy http://{username}:{password}@proxyhk.huawei.com:8080", + f"git config --global http.proxy http://{username}:{password}@proxyhk.huawei.com:8080", + f"git config --global https.proxy http://{username}:{password}@proxy.huawei.com:8080", + f"git config --global http.proxy http://{username}:{password}@proxy.huawei.com:8080", + f"git config --global http.sslVerify false" + ] + for cmd in init_cmds: + run_cmd(cmd) + + +# Get the repository name and PR number +def extract_repo_and_pr(url): + # ָ URL Իȡ· + path = url.split('/')[-3:] + # URL ʽǷ gitee.com/<û>/<ֿ>/pulls/ + # path[-3] ûpath[-2] 'pulls'path[-1] PR + # ֻԲֿ PR ŸȤ + repo_name = path[-3] # Ϊֱȡֿ + pr_number = path[-1] + return repo_name, pr_number + + +# Read the file diff from the files.json of the PR +def read_diff_files(repo_name): + diff_files = [] + path = f'{repo_name}{mix}files.json' + if os.path.exists(path): + files = open(f'{repo_name}{mix}files.json', 'r', encoding='utf-8') + json_obj = json.loads(files.read()) + for o in json_obj['diffs']: + diff_files.append(o['head']['name']) + else: + print(f'ļ{path}') + return diff_files + + +# Change the slash in the path to a system match +def change_mix(txt): + if "\\" in txt: + return str(txt).replace("\\", mix) + if "/" in txt: + return str(txt).replace("/", mix) + + +# Push the diff file to the project code +def push_diff_file_to_code(repo_name, target_path, diff_files): + for diff_file in diff_files: + old_file_path = f'{repo_name}{mix}{diff_file}' + new_file_path = f'{target_path}{mix}{diff_file}' + if os.path.exists(old_file_path): + os.makedirs(os.path.dirname(new_file_path), exist_ok=True) + shutil.copy(old_file_path, new_file_path) + else: + print(f'ļ{old_file_path}') + + +# Submit a single repository +def git_commit(repo_name, pr_number, target_path): + try: + run_cmd(f'repo start ohos_{repo_name}_pr_{pr_number}', target_path) + run_cmd(f'git add .', target_path) + commit_msg = ("TicketNo: DTS2024012002271\nDescription:test\nTeam:OTHERS\nFeature or Bugfix:Bugfix\n" + "Binary Source:No\nPrivateCode(Yes/No):No") + run_cmd(f'git commit -m "' + commit_msg + '"', target_path) + except Exception as e: + print(f"git_commit{repo_name}ֿʧ") + + +# Upload as a CR link +def repo_upload(target_path): + print("please goto code and run \"repo upload\"") + # run_cmd(f'repo upload .', target_path) + + +# Download the codes and diffs for all PRs +def download_prs(pr): + repo_name, pr_number = extract_repo_and_pr(pr) + clone_git_url = f"https://gitee.com/openharmony/{repo_name}.git" + cmd = f"git clone {clone_git_url}" + try: + if not os.path.exists(repo_name): + run_cmd(cmd) + else: + print(f"Ѵ{repo_name}") + cmd = f'git fetch {clone_git_url} pull/{pr_number}/head:pr_{pr_number}' + run_cmd(cmd, repo_name) + run_cmd(f'git checkout pr_{pr_number}', repo_name) + except Exception as e: + print(f"ȡ{repo_name}ֿpull_{pr_number}ʧ") + files_url = f'{pr}/files.json' + files_target_path = f'{repo_name}{mix}files.json' + if not os.path.exists(files_target_path): + cmd = f'curl -o {files_target_path} {files_url} --ssl-no-revoke' + try: + run_cmd(cmd) + except Exception as e: + print(f"ȡ{repo_name}ֿfilesʧ") + else: + print(f"Ѵ{files_target_path}") + diff_files = read_diff_files(repo_name) + + if repo_name not in repo_name_for_code_map: + print(f"{repo_name}·ڣ") + return + target_path = repo_name_for_code_map[repo_name] + + push_diff_file_to_code(repo_name, target_path, diff_files) + git_commit(repo_name, pr_number, target_path) + repo_upload(target_path) + + +if __name__ == "__main__": + init_environment() + for pr in prs: + download_prs(pr) + pass -- Gitee From 10b638014b0c4338b77f31ddc681496e06a823ac Mon Sep 17 00:00:00 2001 From: j30052480 Date: Sat, 10 Aug 2024 17:27:26 +0800 Subject: [PATCH 0122/1485] feat: power independent compile modify Signed-off-by: j30052480 --- power/bundle.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/power/bundle.json b/power/bundle.json index 35c4912dc3..29767be0e2 100755 --- a/power/bundle.json +++ b/power/bundle.json @@ -32,7 +32,8 @@ "hilog", "hisysevent", "libxml2", - "ipc" + "ipc", + "jsoncpp" ], "third_party": [ "jsoncpp" -- Gitee From 549e1f58bc0de985551e80d863e26ed2f930bc4a Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Sat, 10 Aug 2024 18:51:42 +0800 Subject: [PATCH 0123/1485] commit msg Signed-off-by: xuxuehai --- audio/hdi_service/primary_impl/BUILD.gn | 1 + .../primary_impl/vdi_src/audio_adapter_vdi.c | 11 ++++++++--- .../primary_impl/vdi_src/audio_adapter_vdi.h | 3 ++- .../primary_impl/vdi_src/audio_manager_vdi.c | 2 +- .../primary_impl/vdi_src/audio_render_vdi.c | 9 ++++++--- .../primary_impl/vdi_src/audio_render_vdi.h | 4 ++-- .../common/adapter/src/audio_idlhdi_adapter_test.cpp | 4 ---- 7 files changed, 20 insertions(+), 14 deletions(-) diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index 2d86a99dfb..169e01a8b5 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -67,6 +67,7 @@ ohos_shared_library("audio_primary_impl_vendor") { external_deps = [ "drivers_interface_audio:libaudio_proxy_4.0", "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdf_utils", "hdf_core:libhdi", "hdf_core:libpub_utils", "hilog:libhilog", diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index 7f29f6e9a8..bbc10f7113 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -25,6 +25,7 @@ #include "audio_render_vdi.h" #include "audio_dfx_vdi.h" #include "v4_0/iaudio_callback.h" +#include "hdf_dlist.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL static pthread_mutex_t g_adapterMutex; @@ -33,6 +34,7 @@ struct AudioAdapterInfo { struct IAudioAdapterVdi *vdiAdapter; struct IAudioAdapter *adapter; uint32_t refCnt; + char *adapterName; }; struct AudioAdapterPrivVdi { @@ -135,9 +137,10 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); + struct AudioAdapterInfo *adapterInfo = CONTAINER_OF(adapter, struct AudioAdapterInfo, adapter); pthread_mutex_lock(&g_adapterMutex); - *render = FindRenderCreated(desc->pins, attrs, renderId); + *render = FindRenderCreated(desc->pins, attrs, renderId, adapterInfo->adapterName); if (*render != NULL) { AUDIO_FUNC_LOGE("already created"); pthread_mutex_unlock(&g_adapterMutex); @@ -158,7 +161,7 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe pthread_mutex_unlock(&g_adapterMutex); return HDF_FAILURE; } - *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc); + *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc, adapterInfo->adapterName); if (*render == NULL) { (void)vdiAdapter->DestroyRender(vdiAdapter, vdiRender); AUDIO_FUNC_LOGE("Create audio render failed"); @@ -624,7 +627,8 @@ void AudioEnforceClearAdapterRefCntVdi(uint32_t descIndex) AUDIO_FUNC_LOGI("clear adapter ref count zero"); } -struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter) +struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter, + char *adapterName) { if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) { AUDIO_FUNC_LOGE("create adapter error, descIndex=%{public}d", descIndex); @@ -652,6 +656,7 @@ struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAda priv->adapterInfo[descIndex].vdiAdapter = vdiAdapter; priv->adapterInfo[descIndex].adapter = adapter; priv->adapterInfo[descIndex].refCnt = 1; + priv->adapterInfo[descIndex].adapterName = adapterName; AUDIO_FUNC_LOGD(" audio vdiAdapter create adapter success, refcount[1]"); return adapter; diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.h b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.h index 9e60c7a3da..0d4ecd4d0f 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.h +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.h @@ -20,7 +20,8 @@ #include "v4_0/iaudio_adapter.h" #include -struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter); +struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter, + char *adapterName); void AudioReleaseAdapterVdi(uint32_t descIndex); struct IAudioAdapterVdi *AudioGetVdiAdapterByDescIndexVdi(uint32_t descIndex); int32_t AudioIncreaseAdapterRefVdi(uint32_t descIndex, struct IAudioAdapter **adapter); diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index 8e61adcc16..5ca146c97d 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -374,7 +374,7 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc return HDF_FAILURE; } - *adapter = AudioCreateAdapterVdi(descIndex, vdiAdapter); + *adapter = AudioCreateAdapterVdi(descIndex, vdiAdapter, desc->adapterName); if (*adapter == NULL) { AUDIO_FUNC_LOGE("audio vdiManager create adapter fail"); priv->vdiManager->UnloadAdapter(priv->vdiManager, vdiAdapter); diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index ccde8a0d67..e744ea169d 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -36,6 +36,7 @@ struct AudioRenderInfo { unsigned int usrCount; struct IAudioCallback *callback; bool isRegCb; + char *adapterName; }; struct AudioRenderPrivVdi { @@ -885,7 +886,7 @@ static void AudioInitRenderInstanceVdi(struct IAudioRender *render) } struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct AudioSampleAttributes *attrs, - uint32_t *rendrId) + uint32_t *rendrId, const char *adapterName) { if (attrs->type == AUDIO_MMAP_NOIRQ) { AUDIO_FUNC_LOGI("render type is mmap"); @@ -906,7 +907,8 @@ struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct Audio for (index = 0; index < AUDIO_VDI_STREAM_NUM_MAX; index++) { if ((renderPriv->renderInfos[index] != NULL) && (attrs->type == AUDIO_IN_MEDIA || attrs->type == AUDIO_MULTI_CHANNEL) && - (renderPriv->renderInfos[index]->streamType == attrs->type)) { + (renderPriv->renderInfos[index]->streamType == attrs->type) && + (renderPriv->renderInfos[index]->adapterName == adapterName)) { *rendrId = renderPriv->renderInfos[index]->renderId; renderPriv->renderInfos[index]->usrCount++; return &renderPriv->renderInfos[index]->render; @@ -949,7 +951,7 @@ static uint32_t GetAvailableRenderId(struct AudioRenderPrivVdi *renderPriv) } struct IAudioRender *AudioCreateRenderByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *renderId, - struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc) + struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc, char *adapterName) { struct IAudioRender *render = NULL; if (attrs == NULL || renderId == NULL || vdiRender == NULL || desc == NULL) { @@ -989,6 +991,7 @@ struct IAudioRender *AudioCreateRenderByIdVdi(const struct AudioSampleAttributes priv->renderInfos[*renderId]->usrCount = 1; priv->renderInfos[*renderId]->callback = NULL; priv->renderInfos[*renderId]->isRegCb = false; + priv->renderInfos[*renderId]->adapterName = adapterName; render = &(priv->renderInfos[*renderId]->render); AudioInitRenderInstanceVdi(render); diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.h b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.h index 91427f3a07..3ed50e1cb1 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.h +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.h @@ -20,11 +20,11 @@ #include "v4_0/iaudio_render.h" struct IAudioRender *AudioCreateRenderByIdVdi(const struct AudioSampleAttributes *attrs, uint32_t *renderId, - struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc); + struct IAudioRenderVdi *vdiRender, const struct AudioDeviceDescriptor *desc, char *adapterName); void AudioDestroyRenderByIdVdi(uint32_t renderId); struct IAudioRenderVdi *AudioGetVdiRenderByIdVdi(uint32_t renderId); struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct AudioSampleAttributes *attrs, - uint32_t *rendrId); + uint32_t *rendrId, const char *adapterName); uint32_t DecreaseRenderUsrCount(uint32_t renderId); #endif // AUDIO_RENDER_VDI_H diff --git a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp index d5cca43d0d..8e3ec2b3c2 100644 --- a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp +++ b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp @@ -801,7 +801,6 @@ HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_004, TestSize.Level1) struct IAudioRender *render = nullptr; struct AudioSampleAttributes attrs = {}; struct AudioDeviceDescriptor devDesc = {}; - uint32_t channelCountErr = 5; // invalid channelCount ASSERT_NE(nullptr, manager); ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort); ASSERT_EQ(HDF_SUCCESS, ret); @@ -811,9 +810,6 @@ HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_004, TestSize.Level1) attrs.format = AUDIO_FORMAT_TYPE_AAC_MAIN; ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_); ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS); - attrs.channelCount = channelCountErr; - ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_); - EXPECT_EQ(HDF_FAILURE, ret); attrs.type = AUDIO_IN_COMMUNICATION; ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_); EXPECT_EQ(HDF_FAILURE, ret); -- Gitee From 24142894ebe1a9625addf7d02edf36215b47ed2d Mon Sep 17 00:00:00 2001 From: pxd2022 Date: Sat, 10 Aug 2024 07:16:49 +0000 Subject: [PATCH 0124/1485] add hardcursor test example Signed-off-by: pxd2022 --- .../src/display_composer_service.cpp | 12 ++-- display/composer/test/benchmark/BUILD.gn | 4 +- .../test/benchmark/display_benchmark_test.cpp | 68 ++++++++++++++++++- display/composer/test/common/BUILD.gn | 4 +- .../test/common/display_test_utils.cpp | 2 +- .../test/common/hdi_composition_check.h | 2 +- .../composer/test/common/hdi_test_device.cpp | 4 +- .../composer/test/common/hdi_test_device.h | 10 +-- .../composer/test/common/hdi_test_layer.cpp | 7 +- .../fuzztest/common/display_common_fuzzer.h | 4 +- .../test/fuzztest/device_fuzzer/BUILD.gn | 4 +- .../fuzztest/device_fuzzer/device_fuzzer.cpp | 44 +++++++++++- display/composer/test/unittest/BUILD.gn | 4 +- .../test/unittest/hdi_composer_ut.cpp | 40 +++++++++-- .../composer/test/unittest/hdi_composer_ut.h | 4 +- .../composer/test/unittest/hdi_death_test.cpp | 6 +- .../composer/test/unittest/hdi_death_test.h | 8 +-- 17 files changed, 180 insertions(+), 47 deletions(-) diff --git a/display/composer/hdi_service/src/display_composer_service.cpp b/display/composer/hdi_service/src/display_composer_service.cpp index f2de3d2203..207ab8c1e9 100644 --- a/display/composer/hdi_service/src/display_composer_service.cpp +++ b/display/composer/hdi_service/src/display_composer_service.cpp @@ -373,9 +373,9 @@ int32_t DisplayComposerService::SetHardwareCursorPosition(uint32_t devId, int32_ { DISPLAY_TRACE; - CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_FAILURE); + CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_ERR_NOT_SUPPORT); int32_t ret = vdiImplV1_1_->SetHardwareCursorPosition(devId, x, y); - DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, HDF_FAILURE, DISPLAY_LOGE(" fail")); + DISPLAY_CHK_RETURN(ret != HDF_SUCCESS && ret != HDF_ERR_NOT_SUPPORT, HDF_FAILURE, DISPLAY_LOGE(" fail")); return ret; } @@ -383,9 +383,9 @@ int32_t DisplayComposerService::EnableHardwareCursorStats(uint32_t devId, bool e { DISPLAY_TRACE; - CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_FAILURE); + CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_ERR_NOT_SUPPORT); int32_t ret = vdiImplV1_1_->EnableHardwareCursorStats(devId, enable); - DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, HDF_FAILURE, DISPLAY_LOGE(" fail")); + DISPLAY_CHK_RETURN(ret != HDF_SUCCESS && ret != HDF_ERR_NOT_SUPPORT, HDF_FAILURE, DISPLAY_LOGE(" fail")); return ret; } @@ -393,9 +393,9 @@ int32_t DisplayComposerService::GetHardwareCursorStats(uint32_t devId, uint32_t& { DISPLAY_TRACE; - CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_FAILURE); + CHECK_NULLPOINTER_RETURN_VALUE(vdiImplV1_1_, HDF_ERR_NOT_SUPPORT); int32_t ret = vdiImplV1_1_->GetHardwareCursorStats(devId, frameCount, vsyncCount); - DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, HDF_FAILURE, DISPLAY_LOGE(" fail")); + DISPLAY_CHK_RETURN(ret != HDF_SUCCESS && ret != HDF_ERR_NOT_SUPPORT, HDF_FAILURE, DISPLAY_LOGE(" fail")); return ret; } diff --git a/display/composer/test/benchmark/BUILD.gn b/display/composer/test/benchmark/BUILD.gn index 7ccb931b4c..d644ebd901 100644 --- a/display/composer/test/benchmark/BUILD.gn +++ b/display/composer/test/benchmark/BUILD.gn @@ -37,8 +37,8 @@ ohos_benchmarktest("hdf_display_benchmark_test") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", - "drivers_interface_display:libdisplay_composer_stub_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_stub_1.2", "googletest:gtest", "hdf_core:libhdf_utils", "hdf_core:libhdi", diff --git a/display/composer/test/benchmark/display_benchmark_test.cpp b/display/composer/test/benchmark/display_benchmark_test.cpp index a35b58800b..b41ef9f621 100644 --- a/display/composer/test/benchmark/display_benchmark_test.cpp +++ b/display/composer/test/benchmark/display_benchmark_test.cpp @@ -20,7 +20,7 @@ #include #include #include "gtest/gtest.h" -#include "v1_1/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "v1_1/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" @@ -32,11 +32,11 @@ #include "hdi_test_render_utils.h" using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; using namespace OHOS::HDI::Display::TEST; using namespace testing::ext; -static sptr g_composerDevice = nullptr; +static sptr g_composerDevice = nullptr; static std::shared_ptr g_gralloc = nullptr; static std::vector g_displayIds; @@ -591,6 +591,68 @@ BENCHMARK_F(DisplayBenchmarkTest, SetDisplayClientCropTest)(benchmark::State &st BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)-> Iterations(30)->Repetitions(3)->ReportAggregatesOnly(); +/** + * @tc.name: SetHardwareCursorPositionTest + * @tc.desc: Benchmarktest for interface SetHardwareCursorPositionTest. + */ +BENCHMARK_F(DisplayBenchmarkTest, SetHardwareCursorPositionTest)(benchmark::State &state) +{ + int32_t ret = 0; + int32_t x = 1; + int32_t y = 1; + for (auto _ : state) { + ret = g_composerDevice->SetHardwareCursorPosition(g_displayIds[0], x, y); + } + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + +BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetHardwareCursorPositionTest)-> + Iterations(30)->Repetitions(3)->ReportAggregatesOnly(); + +/** + * @tc.name: EnableHardwareCursorStatsTest + * @tc.desc: Benchmarktest for interface EnableHardwareCursorStatsTest. + */ +BENCHMARK_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)(benchmark::State &state) +{ + int32_t ret = 0; + bool enable = true; + for (auto _ : state) { + ret = g_composerDevice->EnableHardwareCursorStats(g_displayIds[0], enable); + } + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + +BENCHMARK_REGISTER_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)-> + Iterations(30)->Repetitions(3)->ReportAggregatesOnly(); + +/** + * @tc.name: GetHardwareCursorStatsTest + * @tc.desc: Benchmarktest for interface GetHardwareCursorStatsTest. + */ +BENCHMARK_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)(benchmark::State &state) +{ + int32_t ret = 0; + uint32_t frameCount = 0; + uint32_t vsyncCount = 0; + for (auto _ : state) { + ret = g_composerDevice->GetHardwareCursorStats(g_displayIds[0], frameCount, vsyncCount); + } + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + +BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)-> + Iterations(30)->Repetitions(3)->ReportAggregatesOnly(); + } // namespace int main(int argc, char** argv) diff --git a/display/composer/test/common/BUILD.gn b/display/composer/test/common/BUILD.gn index 044d4a4d47..c2ffb6053a 100644 --- a/display/composer/test/common/BUILD.gn +++ b/display/composer/test/common/BUILD.gn @@ -39,8 +39,8 @@ ohos_static_library("disp_dev_hdi_test_common") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", - "drivers_interface_display:libdisplay_composer_stub_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_stub_1.2", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", "hilog:libhilog", diff --git a/display/composer/test/common/display_test_utils.cpp b/display/composer/test/common/display_test_utils.cpp index e4ddaaf0a4..9b22b08ead 100644 --- a/display/composer/test/common/display_test_utils.cpp +++ b/display/composer/test/common/display_test_utils.cpp @@ -20,7 +20,7 @@ #include "display_test.h" #include "buffer_handle.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "v1_0/include/idisplay_buffer.h" namespace OHOS { diff --git a/display/composer/test/common/hdi_composition_check.h b/display/composer/test/common/hdi_composition_check.h index b7b31c95e8..ce3a5d3724 100644 --- a/display/composer/test/common/hdi_composition_check.h +++ b/display/composer/test/common/hdi_composition_check.h @@ -15,7 +15,7 @@ #ifndef HDI_COMPOSITION_CHECK_H #define HDI_COMPOSITION_CHECK_H -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "display_test_utils.h" namespace OHOS { diff --git a/display/composer/test/common/hdi_test_device.cpp b/display/composer/test/common/hdi_test_device.cpp index 5b68536bb2..b9dda1bb6d 100644 --- a/display/composer/test/common/hdi_test_device.cpp +++ b/display/composer/test/common/hdi_test_device.cpp @@ -16,7 +16,7 @@ #include "hdi_test_device.h" #include #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "hdi_test_device_common.h" namespace OHOS { @@ -43,7 +43,7 @@ void HdiTestDevice::HotPlug(uint32_t outputId, bool connected, void* data) int32_t HdiTestDevice::InitDevice() { - displayDevice_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayDevice_ = Composer::V1_2::IDisplayComposerInterface::Get(); DISPLAY_TEST_CHK_RETURN((displayDevice_ == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("get IDisplayComposerInterface failed")); diff --git a/display/composer/test/common/hdi_test_device.h b/display/composer/test/common/hdi_test_device.h index 91e878adbf..bdcac34597 100644 --- a/display/composer/test/common/hdi_test_device.h +++ b/display/composer/test/common/hdi_test_device.h @@ -18,8 +18,8 @@ #include #include #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/include/idisplay_composer_interface.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/include/idisplay_composer_interface.h" +#include "v1_2/display_composer_type.h" #include "hdi_test_device_common.h" #include "hdi_test_display.h" #include "hdi_test_layer.h" @@ -29,7 +29,7 @@ namespace HDI { namespace Display { namespace TEST { using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; class HdiTestDevice { public: static HdiTestDevice& GetInstance(); @@ -42,7 +42,7 @@ public: return gralloc_; } - sptr &GetDeviceInterface() + sptr &GetDeviceInterface() { return displayDevice_; } @@ -55,7 +55,7 @@ private: std::shared_ptr FindDisplayOrCreate(uint32_t id); std::map> displays_; - sptr displayDevice_; + sptr displayDevice_; std::shared_ptr gralloc_ = nullptr; std::vector displayIds_; }; diff --git a/display/composer/test/common/hdi_test_layer.cpp b/display/composer/test/common/hdi_test_layer.cpp index ad5c506ef6..f4d01e2672 100644 --- a/display/composer/test/common/hdi_test_layer.cpp +++ b/display/composer/test/common/hdi_test_layer.cpp @@ -18,14 +18,14 @@ #include "hdi_test_device.h" #include "v1_0/include/idisplay_buffer.h" #include "v1_0/display_buffer_type.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" namespace OHOS { namespace HDI { namespace Display { namespace TEST { using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; HdiGrallocBuffer::HdiGrallocBuffer(uint32_t seqNo, uint32_t w, uint32_t h, Composer::V1_0::PixelFormat fmt) { @@ -33,7 +33,8 @@ HdiGrallocBuffer::HdiGrallocBuffer(uint32_t seqNo, uint32_t w, uint32_t h, Compo AllocInfo info = { 0 }; info.width = w; info.height = h; - info.usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE; + info.usage = Composer::V1_2::HBM_USE_MEM_DMA | Composer::V1_2::HBM_USE_CPU_READ | + Composer::V1_2::HBM_USE_CPU_WRITE; info.format = fmt; BufferHandle* buffer = nullptr; diff --git a/display/composer/test/fuzztest/common/display_common_fuzzer.h b/display/composer/test/fuzztest/common/display_common_fuzzer.h index 8c73f8a143..efffc8b437 100644 --- a/display/composer/test/fuzztest/common/display_common_fuzzer.h +++ b/display/composer/test/fuzztest/common/display_common_fuzzer.h @@ -17,8 +17,8 @@ #define DISPLAY_COMMON_FUZZER_H #include "v1_0/include/idisplay_buffer.h" -#include "v1_1/include/idisplay_composer_interface.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/include/idisplay_composer_interface.h" +#include "v1_2/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "buffer_handle.h" #include "hdf_log.h" diff --git a/display/composer/test/fuzztest/device_fuzzer/BUILD.gn b/display/composer/test/fuzztest/device_fuzzer/BUILD.gn index f7fb174ae7..ea05a1c670 100644 --- a/display/composer/test/fuzztest/device_fuzzer/BUILD.gn +++ b/display/composer/test/fuzztest/device_fuzzer/BUILD.gn @@ -24,8 +24,8 @@ ohos_fuzztest("DeviceFuzzTest") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", - "drivers_interface_display:libdisplay_composer_stub_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_stub_1.2", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", "hilog:libhilog", diff --git a/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp b/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp index 3a4a28cd29..ea0331fee7 100644 --- a/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp +++ b/display/composer/test/fuzztest/device_fuzzer/device_fuzzer.cpp @@ -24,9 +24,9 @@ namespace OHOS { using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; -static sptr g_composerInterface = nullptr; +static sptr g_composerInterface = nullptr; static std::shared_ptr g_bufferInterface = nullptr; static bool g_isInit = false; @@ -208,6 +208,41 @@ int32_t TestGetDisplayProperty(uint32_t devId) return ret; } +int32_t TestSetHardwareCursorPosition(uint32_t devId) +{ + int32_t x = GetData(); + int32_t y = GetData(); + int32_t ret = g_composerInterface->SetHardwareCursorPosition(devId, x, y); + if ((ret != DISPLAY_SUCCESS) && (ret != DISPLAY_NOT_SUPPORT)) { + HDF_LOGE("%{public}s: function SetHardwareCursorPosition failed, %{public}d", __func__, ret); + return DISPLAY_FAILURE; + } + return DISPLAY_SUCCESS; +} + +int32_t TestEnableHardwareCursorStats(uint32_t devId) +{ + bool enable = GetRandBoolValue(GetData()); + int32_t ret = g_composerInterface->EnableHardwareCursorStats(devId, enable); + if ((ret != DISPLAY_SUCCESS) && (ret != DISPLAY_NOT_SUPPORT)) { + HDF_LOGE("%{public}s: function EnableHardwareCursorStats failed, %{public}d", __func__, ret); + return DISPLAY_FAILURE; + } + return DISPLAY_SUCCESS; +} + +int32_t TestGetHardwareCursorStats(uint32_t devId) +{ + uint32_t frameCount = GetData(); + uint32_t vsyncCount = GetData(); + int32_t ret = g_composerInterface->GetHardwareCursorStats(devId, frameCount, vsyncCount); + if ((ret != DISPLAY_SUCCESS) && (ret != DISPLAY_NOT_SUPPORT)) { + HDF_LOGE("%{public}s: function GetHardwareCursorStats failed, %{public}d", __func__, ret); + return DISPLAY_FAILURE; + } + return DISPLAY_SUCCESS; +} + int32_t TestGetDisplayCompChange(uint32_t devId) { std::vector layers; @@ -456,6 +491,9 @@ TestFuncs g_testFuncs = { TestPrepareDisplayLayers, TestSetGetDisplayBacklight, TestGetDisplayProperty, + TestSetHardwareCursorPosition, + TestEnableHardwareCursorStats, + TestGetHardwareCursorStats, TestGetDisplayCompChange, TestSetDisplayClientCrop, TestSetDisplayClientDamage, @@ -485,7 +523,7 @@ bool FuzzTest(const uint8_t* rawData, size_t size) // initialize service if (!g_isInit) { g_isInit = true; - g_composerInterface = Composer::V1_1::IDisplayComposerInterface::Get(); + g_composerInterface = Composer::V1_2::IDisplayComposerInterface::Get(); if (g_composerInterface == nullptr) { HDF_LOGE("%{public}s: get IDisplayComposerInterface failed", __func__); return false; diff --git a/display/composer/test/unittest/BUILD.gn b/display/composer/test/unittest/BUILD.gn index 369d1ec54b..c2210daacc 100644 --- a/display/composer/test/unittest/BUILD.gn +++ b/display/composer/test/unittest/BUILD.gn @@ -39,8 +39,8 @@ ohos_unittest("composer_ut") { "c_utils:utils", "drivers_interface_display:libdisplay_buffer_hdi_impl", "drivers_interface_display:libdisplay_buffer_stub_1.0", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.1", - "drivers_interface_display:libdisplay_composer_stub_1.1", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_stub_1.2", "googletest:gtest", "graphic_surface:buffer_handle", "hdf_core:libhdf_utils", diff --git a/display/composer/test/unittest/hdi_composer_ut.cpp b/display/composer/test/unittest/hdi_composer_ut.cpp index a1bfbbc995..c8b85c5460 100644 --- a/display/composer/test/unittest/hdi_composer_ut.cpp +++ b/display/composer/test/unittest/hdi_composer_ut.cpp @@ -18,8 +18,8 @@ #include #include #include "v1_0/include/idisplay_composer_interface.h" -#include "v1_1/include/idisplay_composer_interface.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/include/idisplay_composer_interface.h" +#include "v1_2/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" #include "display_test_utils.h" @@ -33,11 +33,11 @@ #include using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; using namespace OHOS::HDI::Display::TEST; using namespace testing::ext; -static sptr g_composerDevice = nullptr; +static sptr g_composerDevice = nullptr; static std::shared_ptr g_gralloc = nullptr; static std::vector g_displayIds; const int SLEEP_CONT_10 = 10; @@ -323,6 +323,38 @@ HWTEST_F(DeviceTest, test_GetDisplayProperty, TestSize.Level1) EXPECT_EQ(DISPLAY_SUCCESS, result); } +HWTEST_F(DeviceTest, test_SetHardwareCursorPosition, TestSize.Level1) +{ + int32_t x = 1; + int32_t y = 1; + auto ret = g_composerDevice->SetHardwareCursorPosition(g_displayIds[0], x, y); + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + +HWTEST_F(DeviceTest, test_EnableHardwareCursorStats, TestSize.Level1) +{ + bool enable = true; + auto ret = g_composerDevice->EnableHardwareCursorStats(g_displayIds[0], enable); + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + +HWTEST_F(DeviceTest, test_GetHardwareCursorStats, TestSize.Level1) +{ + uint32_t frameCount = 0; + uint32_t vsyncCount = 0; + auto ret = g_composerDevice->GetHardwareCursorStats(g_displayIds[0], frameCount, vsyncCount); + if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) { + ret = DISPLAY_SUCCESS; + } + EXPECT_EQ(DISPLAY_SUCCESS, ret); +} + HWTEST_F(DeviceTest, test_GetDisplayCompChange, TestSize.Level1) { std::vector layers {}; diff --git a/display/composer/test/unittest/hdi_composer_ut.h b/display/composer/test/unittest/hdi_composer_ut.h index b4b821f731..8152172846 100644 --- a/display/composer/test/unittest/hdi_composer_ut.h +++ b/display/composer/test/unittest/hdi_composer_ut.h @@ -15,7 +15,7 @@ #ifndef HDI_COMPOSER_UT_H #define HDI_COMPOSER_UT_H -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test_utils.h" #include "gtest/gtest.h" @@ -28,7 +28,7 @@ namespace HDI { namespace Display { namespace TEST { using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_1; +using namespace OHOS::HDI::Display::Composer::V1_2; class DeviceTest : public ::testing::Test { protected: diff --git a/display/composer/test/unittest/hdi_death_test.cpp b/display/composer/test/unittest/hdi_death_test.cpp index 8e7ad33016..570ee0718e 100644 --- a/display/composer/test/unittest/hdi_death_test.cpp +++ b/display/composer/test/unittest/hdi_death_test.cpp @@ -23,7 +23,7 @@ #include "hdi_test_device_common.h" #include "hdi_test_display.h" -using namespace OHOS::HDI::Display::Composer::V1_0; +using namespace OHOS::HDI::Display::Composer::V1_2; using namespace OHOS::HDI::Display::TEST; using namespace testing::ext; @@ -39,7 +39,7 @@ void ComposerDiedRecipient::OnRemoteDied(const wptr& remote) HWTEST_F(DeathTest, test_AddDeathRecipient, TestSize.Level1) { - displayComposer_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayComposer_ = Composer::V1_2::IDisplayComposerInterface::Get(); ASSERT_TRUE(displayComposer_ != nullptr); sptr recipient = new ComposerDiedRecipient(); ASSERT_TRUE(recipient != nullptr); @@ -51,7 +51,7 @@ HWTEST_F(DeathTest, test_AddDeathRecipient, TestSize.Level1) HWTEST_F(DeathTest, test_RemoveDeathRecipient, TestSize.Level1) { - displayComposer_ = Composer::V1_1::IDisplayComposerInterface::Get(); + displayComposer_ = Composer::V1_2::IDisplayComposerInterface::Get(); ASSERT_TRUE(displayComposer_ != nullptr); sptr recipient = new ComposerDiedRecipient(); ASSERT_TRUE(recipient != nullptr); diff --git a/display/composer/test/unittest/hdi_death_test.h b/display/composer/test/unittest/hdi_death_test.h index 9b55cb0d92..87e4872bed 100644 --- a/display/composer/test/unittest/hdi_death_test.h +++ b/display/composer/test/unittest/hdi_death_test.h @@ -21,9 +21,9 @@ #include #include -#include "v1_0/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "v1_0/display_buffer_type.h" -#include "v1_0/include/idisplay_composer_interface.h" +#include "v1_2/include/idisplay_composer_interface.h" #include "display_test_utils.h" #include "gtest/gtest.h" @@ -32,11 +32,11 @@ namespace HDI { namespace Display { namespace TEST { using namespace OHOS::HDI::Display::Buffer::V1_0; -using namespace OHOS::HDI::Display::Composer::V1_0; +using namespace OHOS::HDI::Display::Composer::V1_2; class DeathTest : public ::testing::Test { public: - sptr displayComposer_; + sptr displayComposer_; }; } // namespace SYSTEMTEST } // namespace Display -- Gitee From c4b3116a45c0ec970ea96fa3ae2fdcad7e3d6230 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Mon, 12 Aug 2024 00:57:47 +0000 Subject: [PATCH 0125/1485] modify setInterface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/hdi_service/src/usb_impl.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index cd6a23754f..9c5c6928fa 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1450,11 +1450,6 @@ int32_t UsbImpl::SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t al port->busNum, port->devAddr, interfaceId); return HDF_FAILURE; } - if (port->iface[interfaceId] && port->iface[interfaceId]->info.curAltSetting == altIndex) { - HDF_LOGE("%{public}s:bus:%{public}d devAddr:%{public}d interfaceId:%{public}d cur:%{public}d", __func__, - port->busNum, port->devAddr, interfaceId, altIndex); - return HDF_SUCCESS; - } int32_t ret = UsbSelectInterfaceSetting(interfaceHandle, altIndex, &port->iface[interfaceId]); if (ret == HDF_SUCCESS) { -- Gitee From 76e9311861103459f4c93ac6e3f4260d5b6f575a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Mon, 12 Aug 2024 02:40:12 +0000 Subject: [PATCH 0126/1485] add param verifying MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- usb/hdi_service/src/usb_impl.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index 9c5c6928fa..f8e907af4e 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1667,7 +1667,8 @@ int32_t UsbImpl::ControlTransferReadwithLength( controlParams.directon = (UsbRequestDirection)(((static_cast(ctrlParams.requestType)) >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK); controlParams.reqType = static_cast(ctrlParams.requestType); - controlParams.size = ctrlParams.length == 0 ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length; + controlParams.size = (ctrlParams.length <= 0 || ctrlParams.length > MAX_CONTROL_BUFF_SIZE) + ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length; controlParams.data = static_cast(OsalMemCalloc(controlParams.size)); if (controlParams.data == nullptr) { HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__); -- Gitee From d2fbac9d8a96a6025c305cf9924e476d3892c8f3 Mon Sep 17 00:00:00 2001 From: liufeng Date: Mon, 12 Aug 2024 11:51:59 +0800 Subject: [PATCH 0127/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp | 31 +++++++++++-------- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 6 ++-- .../src/camera_professional_uttest_v1_3.cpp | 28 ++++++++--------- 3 files changed, 35 insertions(+), 30 deletions(-) diff --git a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp index 16d2f61301..066fd2402f 100644 --- a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp @@ -43,13 +43,15 @@ bool IsTagValueExistsU8(std::shared_ptr ability, uint32_t tag, u common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - EXPECT_TRUE(entry.data.u8 != nullptr); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == value) { - return true; + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } } + } else { + printf("Find CameraMetadata fail!\n"); + CAMERA_LOGE("Find CameraMetadata fail!"); } return false; } @@ -855,14 +857,17 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_022, TestSize.Level1) cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); - EXPECT_EQ(META_TYPE_BYTE, entry.data_type); - EXPECT_TRUE(entry.data.u8 != nullptr); - for (int i = 0; i < entry.count; i++) { - if (entry.data.u8[i] == OHOS_CAMERA_VIDEO_STABILIZATION_OFF) { - CAMERA_LOGI("OHOS_CAMERA_VIDEO_STABILIZATION_OFF found!"); - } else if (entry.data.u8[i] == OHOS_CAMERA_VIDEO_STABILIZATION_AUTO) { - CAMERA_LOGI("OHOS_CAMERA_VIDEO_STABILIZATION_AUTO found!"); + if (entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == OHOS_CAMERA_VIDEO_STABILIZATION_OFF) { + CAMERA_LOGI("OHOS_CAMERA_VIDEO_STABILIZATION_OFF found!"); + } else if (entry.data.u8[i] == OHOS_CAMERA_VIDEO_STABILIZATION_AUTO) { + CAMERA_LOGI("OHOS_CAMERA_VIDEO_STABILIZATION_AUTO found!"); + } } + } else { + printf("get tag failed.\n"); + CAMERA_LOGE("get tag failed."); } } diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 021a7eed4b..08baf64b38 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -583,9 +583,9 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_011, TestSize.Level1) EXPECT_NE(callbackData, nullptr); camera_metadata_item_t callbackEntry; cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &callbackEntry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - EXPECT_NE(callbackEntry.data.ui32, nullptr); - printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.ui32 != nullptr && entry.count > 0) { + printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]); + } } /** diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index fa3435c75a..66c1936e2c 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -73,7 +73,7 @@ bool GetSupportedPhysicalApertureValues(std::shared_ptr ability) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; int rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10], entry.data.f[14], entry.data.f[18]}; for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) { @@ -721,7 +721,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_014, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0; i < entry.count; i++) { cameraTest->intents = {PREVIEW, STILL_CAPTURE}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); @@ -766,7 +766,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_015, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - for (size_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_OFF) { CAMERA_LOGI("OHOS_CAMERA_AWB_MODE_OFF mode is supported!"); } else if (entry.data.u8[i] == OHOS_CAMERA_AWB_MODE_AUTO) { @@ -882,7 +882,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_017, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, STILL_CAPTURE}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); @@ -922,7 +922,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_018, TestSiz cameraTest->imageDataSaveSwitch = SWITCH_ON; //0:close, 1:open, 2:auto, 3:always_open - for (uint8_t i = 0;i < 4;i++) { + for (uint32_t i = 0;i < 4;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -965,7 +965,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_019, TestSiz cameraTest->imageDataSaveSwitch = SWITCH_ON; //0:normal, 1:bright, 2:soft - for (uint8_t i = 0;i < 3;i++) { + for (uint32_t i = 0;i < 3;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1040,7 +1040,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_021, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1122,7 +1122,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_023, TestSiz EXPECT_NE(cameraTest->ability, nullptr); GetSupportedPhysicalApertureValues(cameraTest->ability); - for (uint8_t i = 0;i < supportedPhysicalApertureValues_.size();i++) { + for (uint32_t i = 0;i < supportedPhysicalApertureValues_.size();i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1171,7 +1171,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_024, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_EXPOSURE_TIME_RANGE, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.r != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1259,7 +1259,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_026, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1309,7 +1309,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_027, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1355,7 +1355,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_028, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_AWB_AVAILABLE_MODES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1401,7 +1401,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_029, TestSiz cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry); if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - for (uint8_t i = 0;i < entry.count;i++) { + for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, VIDEO}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_VIDEO); @@ -1442,7 +1442,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_030, TestSiz FillCaptureSetting(cameraTest); cameraTest->imageDataSaveSwitch = SWITCH_ON; - for (uint8_t i = 0; i < RESOLUTION_COUNT; i++) { + for (uint32_t i = 0; i < RESOLUTION_COUNT; i++) { // Preview streamInfo cameraTest->streamInfoPre = std::make_shared(); cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre); -- Gitee From 641b129f0277eb86d24952a08d69184674e35b9f Mon Sep 17 00:00:00 2001 From: 18082231538 <1399410084@qq.com> Date: Mon, 12 Aug 2024 14:41:26 +0800 Subject: [PATCH 0128/1485] add bluetooth a2dp hitrace Signed-off-by: 18082231538 <1399410084@qq.com> --- bluetooth/audio/hal/hdi_passthrough/BUILD.gn | 1 + .../audio/hal/hdi_passthrough/src/audio_bluetooth_manager.cpp | 2 +- bluetooth/audio/hal/hdi_passthrough/src/audio_render.cpp | 3 +++ bluetooth/bundle.json | 3 ++- 4 files changed, 7 insertions(+), 2 deletions(-) diff --git a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn index f8b8a75903..2a59997f33 100644 --- a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn +++ b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn @@ -87,6 +87,7 @@ ohos_shared_library("hdi_audio_bluetooth") { "c_utils:utils", "ipc:ipc_single", "samgr:samgr_proxy", + "hitrace:hitrace_meter", ] public_configs = [ ":hdi_audio_config" ] diff --git a/bluetooth/audio/hal/hdi_passthrough/src/audio_bluetooth_manager.cpp b/bluetooth/audio/hal/hdi_passthrough/src/audio_bluetooth_manager.cpp index e4f63c99c5..24f2874f5c 100644 --- a/bluetooth/audio/hal/hdi_passthrough/src/audio_bluetooth_manager.cpp +++ b/bluetooth/audio/hal/hdi_passthrough/src/audio_bluetooth_manager.cpp @@ -379,7 +379,7 @@ int StopPlaying() int GetLatency(uint32_t &latency) { - HDF_LOGI("%{public}s", __func__); + HDF_LOGD("%{public}s", __func__); #ifdef A2DP_HDI_SERVICE return (getLatencyFunc(latency) ? HDF_SUCCESS : HDF_FAILURE); #else diff --git a/bluetooth/audio/hal/hdi_passthrough/src/audio_render.cpp b/bluetooth/audio/hal/hdi_passthrough/src/audio_render.cpp index 3c4f2e340a..87d5be592a 100644 --- a/bluetooth/audio/hal/hdi_passthrough/src/audio_render.cpp +++ b/bluetooth/audio/hal/hdi_passthrough/src/audio_render.cpp @@ -17,6 +17,7 @@ #include "audio_adapter_info_common.h" #include "audio_bluetooth_manager.h" #include "audio_render.h" +#include "hitrace_meter.h" namespace OHOS::HDI::Audio_Bluetooth { /* 1 buffer: 8000(8kHz sample rate) * 2(bytes, PCM_16_BIT) * 1(channel) */ /* 1 frame: 1024(sample) * 2(bytes, PCM_16_BIT) * 1(channel) */ @@ -284,6 +285,7 @@ int32_t AudioRenderSetGain(AudioHandle handle, float gain) int32_t AudioRenderGetLatency(struct AudioRender *render, uint32_t *ms) { + HITRACE_METER_NAME(HITRACE_TAG_BLUETOOTH, "BtAudioRenderGetLatency"); struct AudioHwRender *impl = reinterpret_cast(render); if (impl == NULL || ms == NULL) { return AUDIO_HAL_ERR_INVALID_PARAM; @@ -312,6 +314,7 @@ int32_t AudioRenderRenderFramSplit(struct AudioHwRender *hwRender) int32_t AudioRenderRenderFrame(struct AudioRender *render, const void *frame, uint64_t requestBytes, uint64_t *replyBytes) { + HITRACE_METER_FMT(HITRACE_TAG_BLUETOOTH, "renderFrame:%d", requestBytes); HDF_LOGD("AudioRenderRenderFrame"); struct AudioHwRender *hwRender = reinterpret_cast(render); if (hwRender == NULL || frame == NULL || replyBytes == NULL || diff --git a/bluetooth/bundle.json b/bluetooth/bundle.json index de8fc88003..7553b61634 100644 --- a/bluetooth/bundle.json +++ b/bluetooth/bundle.json @@ -24,7 +24,8 @@ "ipc", "samgr", "drivers_interface_bluetooth", - "bluetooth_service" + "bluetooth_service", + "hitrace" ] }, "build": { -- Gitee From 11745cadd82fe623c75459277e4c767a6bb55324 Mon Sep 17 00:00:00 2001 From: liufeng Date: Mon, 12 Aug 2024 14:54:08 +0800 Subject: [PATCH 0129/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp | 7 +++++-- camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp | 2 +- .../test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp | 2 +- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp index 066fd2402f..2bc65b7b8d 100644 --- a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp @@ -716,7 +716,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_017, TestSize.Level1) camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME, &entry); cameraTest->imageDataSaveSwitch = SWITCH_ON; - if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { CAMERA_LOGI("print tag f value start."); for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); @@ -855,7 +855,10 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_022, TestSize.Level1) common_metadata_header_t* data = cameraTest->ability->get(); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) { + printf("get tag failed.\n"); + return; + } CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); if (entry.data.u8 != nullptr && entry.count > 0) { for (int i = 0; i < entry.count; i++) { diff --git a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp index b874a7001b..bf43fffaef 100644 --- a/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/front_camera_hdi_uttest_v1_2.cpp @@ -104,7 +104,7 @@ HWTEST_F(FrontCameraHdiUtTestV1_2, Front_Camera_Device_Hdi_V1_2_002, TestSize.Le camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_VIRTUAL_APERTURE_RANGE, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { // Get Stream Operator cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback(); diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 66c1936e2c..3957586c9a 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -881,7 +881,7 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_017, TestSiz camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SENSOR_WB_VALUES, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { for (uint32_t i = 0;i < entry.count;i++) { cameraTest->intents = {PREVIEW, STILL_CAPTURE}; cameraTest->StartProfessionalStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::PROFESSIONAL_PHOTO); -- Gitee From 51ce6441ac618a2caa5a3646fbb6cc3891ae4186 Mon Sep 17 00:00:00 2001 From: liufeng Date: Mon, 12 Aug 2024 14:55:30 +0800 Subject: [PATCH 0130/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp index 5a9ac810f2..cf5e8a9817 100644 --- a/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp +++ b/camera/test/hdi/v1_1/src/front_camera_tag_uttest_v1_1.cpp @@ -78,7 +78,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_004, TestSize.Level1) printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_SCENE_BEAUTY_VALUES : %d\n", entry.data.u8[i]); @@ -126,7 +126,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_006, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES : %d\n", entry.data.u8[i]); @@ -175,7 +175,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_007, TestSize.Level1) printf("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_SCENE_BEAUTY_TYPES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_SKIN_TONE_VALUES : %d\n", entry.data.i32[i]); @@ -224,7 +224,7 @@ HWTEST_F(FrontCameraTagUtTestV1_1, Camera_Tag_Hdi_V1_1_008, TestSize.Level1) printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!\n"); CAMERA_LOGI("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES data is NULL!"); return; - } else if { + } else { for (size_t i = 0; i < entry.count; i++) { std::shared_ptr meta = std::make_shared(100, 200); printf("OHOS_ABILITY_BEAUTY_SKIN_SMOOTH_VALUES : %d\n", entry.data.u8[i]); -- Gitee From 37d516babb6307197d8c50503256380760059434 Mon Sep 17 00:00:00 2001 From: liufeng Date: Mon, 12 Aug 2024 15:17:16 +0800 Subject: [PATCH 0131/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9camera=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E4=B8=ADTAGS=E5=80=BC=E7=9A=84=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp | 7 +++++-- .../test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp | 6 ++---- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp index 2bc65b7b8d..eff44d2222 100644 --- a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp @@ -1631,8 +1631,11 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_052, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) { + CAMERA_LOGI("get OHOS_ABILITY_VIDEO_STABILIZATION_MODES success!"); + } else { + return; + } if (entry.data.i32 != nullptr && entry.count > 0) { for (size_t i = 0; i < entry.count; i++) { printf("OHOS_ABILITY_NIGHT_MODE_SUPPORTED_EXPOSURE_TIME:%d\n", entry.data.i32[i]); diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 3957586c9a..0329c64e33 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -50,9 +50,7 @@ bool g_isModeExists(std::shared_ptr ability, uint32_t tag, uint8 common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - EXPECT_EQ(ret, 0); - EXPECT_NE(entry.count, 0); - if (entry.data.u8 != nullptr) { + if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (int i = 0; i < entry.count; i++) { if (entry.data.u8[i] == value) { return true; @@ -73,7 +71,7 @@ bool GetSupportedPhysicalApertureValues(std::shared_ptr ability) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; int rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry); - if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) { float entryValues[] = {entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10], entry.data.f[14], entry.data.f[18]}; for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) { -- Gitee From 0b99c338a8c22733d8ff29cd40fd8a6916af069d Mon Sep 17 00:00:00 2001 From: l60050612 Date: Mon, 12 Aug 2024 08:31:19 +0000 Subject: [PATCH 0132/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. Signed-off-by: l60050612 --- audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 6cbbc1adc3..18bca4cbaf 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -113,8 +113,8 @@ int32_t AudioGetRenderPositionVdi(struct IAudioRender *render, uint64_t *frames, struct AudioRenderInfo *renderInfo = (struct AudioRenderInfo *)render; struct IAudioRenderVdi *vdiRender = renderInfo->vdiRender; CHECK_NULL_PTR_RETURN_VALUE(vdiRender, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM); - + CHECK_NULL_PTR_RETURN_VALUE(vdiRender->GetRenderPosition, HDF_ERR_INVALID_PARAM); + int32_t id = SetTimer("Hdi:GetRenderPosition"); HdfAudioStartTrace("Hdi:AudioGetRenderPositionVdi", 0); int32_t ret = vdiRender->GetRenderPosition(vdiRender, frames, (struct AudioTimeStampVdi *)time); -- Gitee From dc70bc55b2a73d75249cfa9e62b54040862edc0b Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Mon, 12 Aug 2024 16:50:07 +0800 Subject: [PATCH 0133/1485] =?UTF-8?q?codec=20HDI=20log=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: suxiaosu007 --- codec/image/hdi_service/src/codec_image_service.cpp | 8 ++++---- codec/image/jpeg/src/codec_jpeg_service.cpp | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/codec/image/hdi_service/src/codec_image_service.cpp b/codec/image/hdi_service/src/codec_image_service.cpp index 4748c61df9..feec21002d 100644 --- a/codec/image/hdi_service/src/codec_image_service.cpp +++ b/codec/image/hdi_service/src/codec_image_service.cpp @@ -43,7 +43,7 @@ int32_t CodecImageService::GetImageCapability(std::vector& int32_t CodecImageService::Init(enum CodecImageRole role) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HdfCodecInit"); - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); if (role == CODEC_IMAGE_JPEG) { CHECK_AND_RETURN_RET_LOG(jpegImpl_ != nullptr, HDF_FAILURE, "jpegImpl_ is null"); return jpegImpl_->JpegInit(); @@ -55,7 +55,7 @@ int32_t CodecImageService::Init(enum CodecImageRole role) int32_t CodecImageService::DeInit(enum CodecImageRole role) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HdfCodecDeInit"); - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); if (role == CODEC_IMAGE_JPEG) { CHECK_AND_RETURN_RET_LOG(jpegImpl_ != nullptr, HDF_FAILURE, "jpegImpl_ is null"); return jpegImpl_->JpegDeInit(); @@ -68,7 +68,7 @@ int32_t CodecImageService::DoJpegDecode(const CodecImageBuffer& inBuffer, const const CodecJpegDecInfo& decInfo) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HdfCodecDoJpegDecode"); - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); if (inBuffer.fenceFd >= 0) { close(inBuffer.fenceFd); } @@ -79,7 +79,7 @@ int32_t CodecImageService::DoJpegDecode(const CodecImageBuffer& inBuffer, const int32_t CodecImageService::AllocateInBuffer(CodecImageBuffer& inBuffer, uint32_t size, CodecImageRole role) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HdfCodecAllocateInBuffer"); - CODEC_LOGI("servcie impl, size [%{public}d]", size); + CODEC_LOGD("servcie impl, size [%{public}d]", size); CHECK_AND_RETURN_RET_LOG(size != 0, HDF_ERR_INVALID_PARAM, "buffer size is 0"); CHECK_AND_RETURN_RET_LOG(size <= CODEC_IMAGE_MAX_BUFFER_SIZE, HDF_ERR_INVALID_PARAM, "buffer size is too large"); inBuffer.bufferRole = role; diff --git a/codec/image/jpeg/src/codec_jpeg_service.cpp b/codec/image/jpeg/src/codec_jpeg_service.cpp index 59a5f154c2..b2186aa1fb 100644 --- a/codec/image/jpeg/src/codec_jpeg_service.cpp +++ b/codec/image/jpeg/src/codec_jpeg_service.cpp @@ -28,7 +28,7 @@ CodecJpegService::CodecJpegService() int32_t CodecJpegService::JpegInit() { - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); CHECK_AND_RETURN_RET_LOG(core_ != nullptr, HDF_FAILURE, "core_ is null"); std::lock_guard lk(initMutex_); int32_t ret = core_->JpegInit(); @@ -40,7 +40,7 @@ int32_t CodecJpegService::JpegInit() int32_t CodecJpegService::JpegDeInit() { - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); CHECK_AND_RETURN_RET_LOG(core_ != nullptr, HDF_FAILURE, "core_ is null"); int32_t ret = core_->JpegDeInit(); @@ -53,7 +53,7 @@ int32_t CodecJpegService::JpegDeInit() int32_t CodecJpegService::DoJpegDecode(const CodecImageBuffer& inBuffer, const CodecImageBuffer& outBuffer, const CodecJpegDecInfo& decInfo) { - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); CHECK_AND_RETURN_RET_LOG(core_ != nullptr, HDF_FAILURE, "core_ is null"); CHECK_AND_RETURN_RET_LOG(inBuffer.buffer != nullptr, HDF_FAILURE, "inBuffer.buffer is null"); CHECK_AND_RETURN_RET_LOG(outBuffer.buffer != nullptr, HDF_FAILURE, "outBuffer.buffer is null"); @@ -72,7 +72,7 @@ int32_t CodecJpegService::DoJpegDecode(const CodecImageBuffer& inBuffer, const C int32_t CodecJpegService::AllocateJpegInBuffer(CodecImageBuffer& inBuffer, uint32_t size) { - CODEC_LOGI("servcie impl!"); + CODEC_LOGD("servcie impl!"); CHECK_AND_RETURN_RET_LOG(core_ != nullptr, HDF_FAILURE, "core_ is null"); BufferHandle *bufferHandle; -- Gitee From 3b0cd9a7002bd1a28c5fdddee0784ec733c6ef08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=B7=A1=E6=B5=B7=E9=BE=99?= <1399410084@qq.com> Date: Mon, 12 Aug 2024 11:08:42 +0000 Subject: [PATCH 0134/1485] update bluetooth/audio/hal/hdi_passthrough/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 淡海龙 <1399410084@qq.com> --- bluetooth/audio/hal/hdi_passthrough/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn index 2a59997f33..9b976aab63 100644 --- a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn +++ b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn @@ -85,9 +85,9 @@ ohos_shared_library("hdi_audio_bluetooth") { } external_deps += [ "c_utils:utils", + "hitrace:hitrace_meter", "ipc:ipc_single", "samgr:samgr_proxy", - "hitrace:hitrace_meter", ] public_configs = [ ":hdi_audio_config" ] -- Gitee From 10ed977d59e30dd6e215bc4caa32ea74c3ee71ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 12 Aug 2024 11:35:46 +0000 Subject: [PATCH 0135/1485] update camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp index eff44d2222..fc26c9688e 100644 --- a/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp +++ b/camera/test/hdi/v1_2/src/camera_hdi_uttest_v1_2.cpp @@ -526,7 +526,7 @@ HWTEST_F(CameraHdiUtTestV1_2, Camera_Device_Hdi_V1_2_012, TestSize.Level1) if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { CAMERA_LOGI("OHOS_ABILITY_SUPPORTED_COLOR_MODES: %{public}d", entry.data.u8[0]); } else { - print("XMage not supported\n"); + printf("XMage not supported\n"); CAMERA_LOGI("XMage not supported"); } } -- Gitee From 942620546867a80589ee6f2f04ffed33ff2bf61a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 12 Aug 2024 13:15:52 +0000 Subject: [PATCH 0136/1485] update camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 0329c64e33..abdbf77fe5 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -50,7 +50,7 @@ bool g_isModeExists(std::shared_ptr ability, uint32_t tag, uint8 common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - if (rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (re == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (int i = 0; i < entry.count; i++) { if (entry.data.u8[i] == value) { return true; -- Gitee From 41190e332fb0700df169de674347cab6d0101fa1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:21:20 +0000 Subject: [PATCH 0137/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- .../primary_impl/vdi_src/audio_adapter_vdi.c | 24 ++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index bbc10f7113..a6706b3d71 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -25,7 +25,6 @@ #include "audio_render_vdi.h" #include "audio_dfx_vdi.h" #include "v4_0/iaudio_callback.h" -#include "hdf_dlist.h" #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL static pthread_mutex_t g_adapterMutex; @@ -81,6 +80,25 @@ static struct IAudioAdapterVdi *AudioGetVdiAdapterVdi(const struct IAudioAdapter return NULL; } +static char *AudioGetAdapterNameVdi(const struct IAudioAdapter *adapter) +{ + struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi(); + + if (adapter == NULL) { + AUDIO_FUNC_LOGE("get AdapterName error"); + return NULL; + } + + for (uint32_t i = 0; i < AUDIO_VDI_ADAPTER_NUM_MAX; i++) { + if (adapter == priv->adapterInfo[i].adapter) { + return priv->adapterInfo[i].adapterName; + } + } + + AUDIO_FUNC_LOGE("audio get adapterName fail"); + return NULL; +} + int32_t AudioInitAllPortsVdi(struct IAudioAdapter *adapter) { CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM); @@ -137,10 +155,10 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM); - struct AudioAdapterInfo *adapterInfo = CONTAINER_OF(adapter, struct AudioAdapterInfo, adapter); pthread_mutex_lock(&g_adapterMutex); - *render = FindRenderCreated(desc->pins, attrs, renderId, adapterInfo->adapterName); + char *adapterName = AudioGetAdapterNameVdi(adapter); + *render = FindRenderCreated(desc->pins, attrs, renderId, adapterName); if (*render != NULL) { AUDIO_FUNC_LOGE("already created"); pthread_mutex_unlock(&g_adapterMutex); -- Gitee From 4d6888389fe9bb6a3ee84d65731d34841a646247 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:22:28 +0000 Subject: [PATCH 0138/1485] update audio/hdi_service/primary_impl/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/BUILD.gn | 1 - 1 file changed, 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index 169e01a8b5..2d86a99dfb 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -67,7 +67,6 @@ ohos_shared_library("audio_primary_impl_vendor") { external_deps = [ "drivers_interface_audio:libaudio_proxy_4.0", "hdf_core:libhdf_ipc_adapter", - "hdf_core:libhdf_utils", "hdf_core:libhdi", "hdf_core:libpub_utils", "hilog:libhilog", -- Gitee From a141e7e555fe7dea36e04cdd99fbb021876e7634 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:26:52 +0000 Subject: [PATCH 0139/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index a6706b3d71..b102474b32 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -674,7 +674,7 @@ struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAda priv->adapterInfo[descIndex].vdiAdapter = vdiAdapter; priv->adapterInfo[descIndex].adapter = adapter; priv->adapterInfo[descIndex].refCnt = 1; - priv->adapterInfo[descIndex].adapterName = adapterName; + priv->adapterInfo[descIndex].adapterName = strdup(adapterName); AUDIO_FUNC_LOGD(" audio vdiAdapter create adapter success, refcount[1]"); return adapter; @@ -693,6 +693,8 @@ void AudioReleaseAdapterVdi(uint32_t descIndex) priv->adapterInfo[descIndex].adapter = NULL; priv->adapterInfo[descIndex].vdiAdapter = NULL; priv->adapterInfo[descIndex].refCnt = UINT_MAX; + OsalMemFree((void *)priv->adapterInfo[descIndex].adapterName); + priv->adapterInfo[descIndex].adapterName = NULL; priv->isRegCb = false; priv->callback = NULL; -- Gitee From 2cfcaa185dfe51f73d35b08fda1e39c6259e6204 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:30:12 +0000 Subject: [PATCH 0140/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- .../primary_impl/vdi_src/audio_render_vdi.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index e744ea169d..9001458584 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -991,7 +991,13 @@ struct IAudioRender *AudioCreateRenderByIdVdi(const struct AudioSampleAttributes priv->renderInfos[*renderId]->usrCount = 1; priv->renderInfos[*renderId]->callback = NULL; priv->renderInfos[*renderId]->isRegCb = false; - priv->renderInfos[*renderId]->adapterName = adapterName; + priv->renderInfos[*renderId]->adapterName = strdup(adapterName); + if (priv->renderInfos[*renderId]->adapterName == NULL) { + OsalMemFree(priv->renderInfos[*renderId]->desc.desc); + OsalMemFree(priv->renderInfos[*renderId]); + priv->renderInfos[*renderId] = NULL; + return NULL; + } render = &(priv->renderInfos[*renderId]->render); AudioInitRenderInstanceVdi(render); @@ -1029,6 +1035,8 @@ void AudioDestroyRenderByIdVdi(uint32_t renderId) return; } + OsalMemFree((void *)priv->renderInfos[renderId]->adapterName); + priv->renderInfos[renderId]->adapterName = NULL; OsalMemFree((void *)priv->renderInfos[renderId]->desc.desc); priv->renderInfos[renderId]->vdiRender = NULL; priv->renderInfos[renderId]->desc.desc = NULL; -- Gitee From c342fd407917bac08c4781c7b6843c3cff3ce7a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:32:39 +0000 Subject: [PATCH 0141/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index b102474b32..7cae14324b 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -675,6 +675,11 @@ struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAda priv->adapterInfo[descIndex].adapter = adapter; priv->adapterInfo[descIndex].refCnt = 1; priv->adapterInfo[descIndex].adapterName = strdup(adapterName); + if (priv->adapterInfo[descIndex]->adapterName == NULL) { + OsalMemFree((void *)priv->adapterInfo[descIndex].adapter); + priv->adapterInfo[descIndex].adapter = NULL; + return NULL; + } AUDIO_FUNC_LOGD(" audio vdiAdapter create adapter success, refcount[1]"); return adapter; -- Gitee From d2054be0133b57ae1055771e357a659b90722ec6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Mon, 12 Aug 2024 13:34:02 +0000 Subject: [PATCH 0142/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index 7cae14324b..9328171310 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -179,7 +179,7 @@ int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDe pthread_mutex_unlock(&g_adapterMutex); return HDF_FAILURE; } - *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc, adapterInfo->adapterName); + *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc, adapterName); if (*render == NULL) { (void)vdiAdapter->DestroyRender(vdiAdapter, vdiRender); AUDIO_FUNC_LOGE("Create audio render failed"); -- Gitee From 8cc64a90eac9cf86c2f341573cbeee3b1cb6cc68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 12 Aug 2024 14:03:13 +0000 Subject: [PATCH 0143/1485] update camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index abdbf77fe5..3c4d4bbb2e 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -50,7 +50,7 @@ bool g_isModeExists(std::shared_ptr ability, uint32_t tag, uint8 common_metadata_header_t* data = ability->get(); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, tag, &entry); - if (re == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { for (int i = 0; i < entry.count; i++) { if (entry.data.u8[i] == value) { return true; -- Gitee From 91f3ac21d404730fd36ba258554c3c08ce16dee2 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 09:51:45 +0800 Subject: [PATCH 0144/1485] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=BA=BF=E7=A8=8B?= =?UTF-8?q?=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/include/input_device_manager.h | 3 +++ input/udriver/src/input_device_manager.cpp | 7 +++++++ 2 files changed, 10 insertions(+) diff --git a/input/udriver/include/input_device_manager.h b/input/udriver/include/input_device_manager.h index 53bb54c50f..6447ecbef3 100644 --- a/input/udriver/include/input_device_manager.h +++ b/input/udriver/include/input_device_manager.h @@ -136,6 +136,9 @@ private: int32_t &epollFd, int32_t &fd, string devPath, std::shared_ptr &detailInfo); mutable std::mutex lock_; + std::mutex reportEventPkgCallBackLock_; + std::mutex reportHotPlugEventCallBackLock_; + std::mutex inputDevListLock_; std::map inputDevList_; struct epoll_event epollEventList_[EPOLL_MAX_EVENTS] {}; std::string devPath_ {"/dev/input"}; diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index 515a228ab8..5c4c3da4ed 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -271,6 +271,7 @@ uint32_t GetInputDeviceTypeInfo(const string &devName) void InputDeviceManager::GetInputDeviceInfoList(int32_t epollFd) { + std::lock_guard guard(inputDevListLock_); inputDevList_.clear(); std::vector flist = GetFiles(devPath_); std::shared_ptr detailInfo; @@ -350,6 +351,7 @@ int32_t InputDeviceManager::DoInputDeviceAction(void) void InputDeviceManager::DeleteDevListNode(int index) { + std::lock_guard guard(inputDevListLock_); for (auto it = inputDevList_.begin(); it != inputDevList_.end();) { if (it->first == (uint32_t)index) { it = inputDevList_.erase(it); @@ -367,6 +369,7 @@ void InputDeviceManager::DeleteDevListNode(int index) int32_t InputDeviceManager::AddDeviceNodeToList( int32_t &epollFd, int32_t &fd, string devPath, std::shared_ptr &detailInfo) { + std::lock_guard guard(inputDevListLock_); if (epollFd < 0 || fd < 0) { HDF_LOGE("%{public}s: param invalid, %{public}d", __func__, __LINE__); return INPUT_FAILURE; @@ -819,6 +822,7 @@ RetStatus InputDeviceManager::RunExtraCommand(uint32_t devIndex, InputExtraCmd * // InputReporter RetStatus InputDeviceManager::RegisterReportCallback(uint32_t devIndex, InputEventCb *callback) { + std::lock_guard guard(reportEventPkgCallBackLock_); RetStatus rc = INPUT_SUCCESS; if ((devIndex >= inputDevList_.size()) || (callback == nullptr) || (callback->EventPkgCallback == nullptr)) { HDF_LOGE("%{public}s: param is wrong", __func__); @@ -830,6 +834,7 @@ RetStatus InputDeviceManager::RegisterReportCallback(uint32_t devIndex, InputEve RetStatus InputDeviceManager::UnregisterReportCallback(uint32_t devIndex) { + std::lock_guard guard(reportEventPkgCallBackLock_); HDF_LOGI("%{public}s: %{public}d dev is unregister", __func__, devIndex); RetStatus rc = INPUT_SUCCESS; if (devIndex >= inputDevList_.size()) { @@ -842,6 +847,7 @@ RetStatus InputDeviceManager::UnregisterReportCallback(uint32_t devIndex) RetStatus InputDeviceManager::RegisterHotPlugCallback(InputHostCb *callback) { + std::lock_guard guard(reportHotPlugEventCallBackLock_); RetStatus rc = INPUT_SUCCESS; reportHotPlugEventCallback_ = callback; HDF_LOGI("%{public}s: called line %{public}d ret %{public}d", __func__, __LINE__, rc); @@ -850,6 +856,7 @@ RetStatus InputDeviceManager::RegisterHotPlugCallback(InputHostCb *callback) RetStatus InputDeviceManager::UnregisterHotPlugCallback(void) { + std::lock_guard guard(reportHotPlugEventCallBackLock_); RetStatus rc = INPUT_SUCCESS; reportHotPlugEventCallback_ = nullptr; HDF_LOGI("%{public}s: called line %{public}d ret:%{public}d", __func__, __LINE__, rc); -- Gitee From 96a5d89436a40b9082473e1b62a6f11bb85b39d2 Mon Sep 17 00:00:00 2001 From: liangqi Date: Fri, 9 Aug 2024 14:35:20 +0800 Subject: [PATCH 0145/1485] =?UTF-8?q?=E5=88=A0=E9=99=A4=E4=B8=8D=E5=90=88?= =?UTF-8?q?=E8=A7=84=E8=8C=83=E7=9A=84tdd=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liangqi --- input/test/unittest/udriver/hdi_input_test.cpp | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/input/test/unittest/udriver/hdi_input_test.cpp b/input/test/unittest/udriver/hdi_input_test.cpp index 341d344503..1ae786f42a 100644 --- a/input/test/unittest/udriver/hdi_input_test.cpp +++ b/input/test/unittest/udriver/hdi_input_test.cpp @@ -1089,19 +1089,6 @@ HWTEST_F(HdiInputTest, ReportEventPkg001, TestSize.Level1) iInputDeviceManager.ReportEventPkg(g_fileDescriptorFirst, evtPkg, COUNT); } -/** - * @tc.name: ReportEventPkg002 - * @tc.desc: Report Event Pkg - * @tc.type: FUNC - * @tc.require: SR000F867Q - */ -HWTEST_F(HdiInputTest, ReportEventPkg002, TestSize.Level1) -{ - printf("%s: [Input] ReportEventPkg002 enter\n", __func__); - InputDeviceManager iInputDeviceManager; - iInputDeviceManager.ReportEventPkg(g_fileDescriptorFirst, nullptr, COUNT); -} - /** * @tc.name: DoRead * @tc.desc: Do Read -- Gitee From 0351b7159e6a7e7f1b479b20e441913cac96e757 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 02:02:48 +0000 Subject: [PATCH 0146/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=91=8A=E8=AD=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- .../hdi_passthrough_additional/input_callback_impl.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp index bcdea7329e..10eb04cbfa 100644 --- a/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp +++ b/input/test/unittest/hdi_passthrough_additional/input_callback_impl.cpp @@ -21,9 +21,9 @@ namespace OHOS { namespace HDI { namespace Input { namespace V1_0 { -InputCallbackImpl::InputCallbackImpl(const wptr &inputInterfaces_, - const wptr &reportCallback_) : inputInterfaces_(inputInterfaces_), - reportCallback_(reportCallback_) +InputCallbackImpl::InputCallbackImpl(const wptr &inputInterfaces, + const wptr &otherCallback) : inputInterfaces_(inputInterfaces), + reportCallback_(otherCallback) {} int32_t InputCallbackImpl::EventPkgCallback(const std::vector &pkgs, uint32_t devIndex) -- Gitee From fbc64d2b2a27e1563e1370fa1de3793009c6e19f Mon Sep 17 00:00:00 2001 From: WangYusen Date: Mon, 12 Aug 2024 15:12:31 +0800 Subject: [PATCH 0147/1485] debug softap black list problem Signed-off-by: WangYusen --- .../hdi_service/service_common/hdi_hostapd_hal.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c index 2c9916c438..775d4a2753 100644 --- a/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c +++ b/wlan/hostapd/interfaces/hdi_service/service_common/hdi_hostapd_hal.c @@ -741,7 +741,8 @@ static int ModBlockList(const char *mac, int id) HDF_LOGE("ModBlockList fclose error"); return -1; } - if (sprintf_s(cmd, sizeof(cmd), "SET deny_mac_file %s/%s", CONFIG_PATH_DIR, CONFIG_DENY_MAC_FILE_NAME) < 0) { + if (sprintf_s(cmd, sizeof(cmd), "IFNAME=%s SET deny_mac_file %s/%s", g_apIfaceName, + CONFIG_PATH_DIR, CONFIG_DENY_MAC_FILE_NAME) < 0) { HDF_LOGE("ModBlockList sprintf_s cmd fail"); return -1; } @@ -757,7 +758,7 @@ static int AddBlocklist(const char *mac, int id) char cmd[BUFSIZE_CMD] = {0}; char buf[BUFSIZE_REQUEST_SMALL] = {0}; - if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "DENY_ACL ADD_MAC %s", mac) < 0) { + if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s DENY_ACL ADD_MAC %s", g_apIfaceName, mac) < 0) { HDF_LOGE("AddBlocklist sprintf_s cmd fail"); return -1; } @@ -784,7 +785,7 @@ static int DelBlocklist(const char *mac, int id) char cmd[BUFSIZE_CMD] = {0}; char buf[BUFSIZE_REQUEST_SMALL] = {0}; - if (sprintf_s(cmd, sizeof(cmd), "DENY_ACL DEL_MAC %s", mac) < 0) { + if (sprintf_s(cmd, sizeof(cmd), "IFNAME=%s DENY_ACL DEL_MAC %s", g_apIfaceName, mac) < 0) { HDF_LOGE("DelBlocklist sprintf_s DENY_ACL cmd fail"); return -1; } @@ -904,7 +905,7 @@ static int DisConnectedDev(const char *mac, int id) char cmd[BUFSIZE_CMD] = {0}; char buf[BUFSIZE_REQUEST_SMALL] = {0}; - if (sprintf_s(cmd, sizeof(cmd), "DISASSOCIATE %s", mac) < 0) { + if (sprintf_s(cmd, sizeof(cmd), "IFNAME=%s DISASSOCIATE %s", g_apIfaceName, mac) < 0) { HDF_LOGE("DisConnectedDev sprintf_s fail"); return -1; } -- Gitee From bb480386d6e98eb62679cf2603cfc5fcf72742ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 11:08:20 +0800 Subject: [PATCH 0148/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/hdi/hdf_vibrator_hdi_test.cpp | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp index 1faabc00f0..845a0834eb 100644 --- a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp +++ b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp @@ -39,6 +39,10 @@ namespace { int32_t g_frequency2 = -200; V1_2::HapticPaket g_pkg = {434, 1, {{V1_2::CONTINUOUS, 0, 149, 100, 50, 0, 4, {{0, 0, 0}, {1, 1, 0}, {32, 1, -39}, {149, 0, -39}}}}}; + V1_2::HapticPaket g_pkg1 = {434, 1, {{V1_2::TRANSIENT, 0, 149, 100, 50, 0, 4, + {{0, 0, 0}, {1, 1, 0}, {32, 1, -39}, {149, 0, -39}}}}}; + int32_t g_vibratorId = 0; + std::vector g_info; constexpr int32_t MIN_DURATION = 0; constexpr int32_t MAX_DURATION = 3600000; std::vector g_effect_list = {"haptic.clock.timer", "haptic.long_press.light", \ @@ -501,6 +505,23 @@ HWTEST_F(HdfVibratorHdiTest, PlayHapticPattern, TestSize.Level1) EXPECT_EQ(endRet, HDF_SUCCESS); } +/** + * @tc.name: PlayHapticPattern + * @tc.desc: HD vibration data packet delivery. + * @tc.type: FUNC + * @tc.require:#I8BZ5H + */ +HWTEST_F(HdfVibratorHdiTest, PlayHapticPattern, TestSize.Level1) +{ + ASSERT_NE(nullptr, g_vibratorInterface); + + int32_t startRet = g_vibratorInterface->PlayHapticPattern(g_pkg1); + EXPECT_EQ(startRet, HDF_SUCCESS); + + int32_t endRet = g_vibratorInterface->StopV1_2(HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_ONCE); + EXPECT_EQ(endRet, HDF_SUCCESS); +} + /** * @tc.name: GetHapticCapacity * @tc.desc: Obtains the vibration capability of the motor. @@ -634,4 +655,52 @@ HWTEST_F(HdfVibratorHdiTest, StartByIntensityTest, TestSize.Level1) int32_t endRet = g_vibratorInterface->StopV1_2(HdfVibratorModeV1_2::HDF_VIBRATOR_MODE_PRESET); EXPECT_EQ(endRet, HDF_SUCCESS); +} + +/** + * @tc.name: StopTest + * @tc.desc: Controls this Performing Time Series Vibrator Effects. + * Controls this vibrator to stop the vibrator + * @tc.type: FUNC + * @tc.require:#I96NNZ + */ +HWTEST_F(HdfVibratorHdiTest, StopTest, TestSize.Level1) +{ + HDF_LOGI("StopTest in"); + ASSERT_NE(nullptr, g_vibratorInterface); + + int32_t startRet = g_vibratorInterface->StartOnce(g_duration); + EXPECT_EQ(startRet, HDF_SUCCESS); + int32_t endRet = g_vibratorInterface->Stop(HdfVibratorMode::HDF_VIBRATOR_MODE_ONCE); + EXPECT_EQ(endRet, HDF_SUCCESS); + OsalMSleep(g_sleepTime1); + + startRet = g_vibratorInterface->StartByIntensity(g_effect1, g_intensity3); + EXPECT_EQ(startRet, HDF_SUCCESS); + endRet = g_vibratorInterface->StopV1_2(HdfVibratorMode::HDF_VIBRATOR_MODE_PRESET); + EXPECT_EQ(endRet, HDF_SUCCESS); + OsalMSleep(g_sleepTime1); + + + int32_t startRet = g_vibratorInterface->Start(g_effect1); + EXPECT_EQ(startRet, HDF_SUCCESS); + int32_t endRet = g_vibratorInterface->Stop(HdfVibratorMode::HDF_VIBRATOR_MODE_BUTT); + EXPECT_EQ(endRet, HDF_ERR_INVALID_PARAM); + OsalMSleep(g_sleepTime1); +} + +/** + * @tc.name: GetAllWaveInfoTest + * @tc.desc: Controls this Performing Time Series Vibrator Effects. + * Controls this vibrator to stop the vibrator + * @tc.type: FUNC + * @tc.require:#I96NNZ + */ +HWTEST_F(HdfVibratorHdiTest, GetAllWaveInfoTest, TestSize.Level1) +{ + HDF_LOGI("StartByIntensityTest in"); + ASSERT_NE(nullptr, g_vibratorInterface); + + int32_t endRet = g_vibratorInterface->GetAllWaveInfo(g_vibratorId, g_info); + EXPECT_EQ(startRet, HDF_SUCCESS); } \ No newline at end of file -- Gitee From 230007a42ce79325f4afa5f60010bf4ba366dfef Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 13 Aug 2024 11:38:08 +0800 Subject: [PATCH 0149/1485] =?UTF-8?q?=E7=A8=B3=E5=AE=9A=E6=80=A7=E9=87=8A?= =?UTF-8?q?=E6=94=BE=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/hdi_wpa_common.c | 5 +++++ .../interfaces/hdi_service/service_common/wpa_common_cmd.c | 1 - 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index e8aeeebe9d..a2721a5f18 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -289,6 +289,11 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) int nameLen = strlen(ifName); ReleaseIfaceCtrl(ifName, nameLen); } + if (ret == 0 && ifName != NULL && + strncmp(cmd, "INTERFACE_REMOVE ", strlen("INTERFACE_REMOVE ")) == 0) { + int nameLen = strlen(ifName); + ReleaseIfaceCtrl(ifName, nameLen); + } pthread_mutex_unlock(&g_mutexWpa); return ret; } diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index df812ba1f6..1c703cfa90 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -2065,7 +2065,6 @@ static int32_t StopWpaSupplicant(void) } else { HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); } - ReleaseWpaGlobalInterface(); HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); return HDF_SUCCESS; } -- Gitee From f036e6eebdd3bd5d68064c28b08ed671803513ef Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 13 Aug 2024 03:52:21 +0000 Subject: [PATCH 0150/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c. Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/hdi_wpa_common.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index a2721a5f18..65e5660f12 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -290,9 +290,8 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) ReleaseIfaceCtrl(ifName, nameLen); } if (ret == 0 && ifName != NULL && - strncmp(cmd, "INTERFACE_REMOVE ", strlen("INTERFACE_REMOVE ")) == 0) { - int nameLen = strlen(ifName); - ReleaseIfaceCtrl(ifName, nameLen); + strncmp(cmd, "TERMINATE ", strlen("TERMINATE ")) == 0) { + ReleaseWpaGlobalInterface(); } pthread_mutex_unlock(&g_mutexWpa); return ret; -- Gitee From 90cd571abc89509a0bb03530218a2bae2b1c6a5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 12:36:15 +0800 Subject: [PATCH 0151/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_client_info.cpp | 1 + sensor/hdi_service/sensor_client_info.h | 1 + .../test/unittest/hdi/hdf_sensor_hdi_test.cpp | 46 ++++++++++++++++++- 3 files changed, 47 insertions(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_client_info.cpp b/sensor/hdi_service/sensor_client_info.cpp index 76efe3d6cf..6a332c8636 100644 --- a/sensor/hdi_service/sensor_client_info.cpp +++ b/sensor/hdi_service/sensor_client_info.cpp @@ -36,6 +36,7 @@ SensorClientInfo::~SensorClientInfo() void SensorClientInfo::SetReportDataCb(const sptr &callbackObj) { + SENSOR_TRACE_PID; pollCallback_ = callbackObj; } diff --git a/sensor/hdi_service/sensor_client_info.h b/sensor/hdi_service/sensor_client_info.h index c5615b6206..dba3517cd1 100644 --- a/sensor/hdi_service/sensor_client_info.h +++ b/sensor/hdi_service/sensor_client_info.h @@ -20,6 +20,7 @@ #include #include "v2_0/isensor_interface.h" #include "isensor_interface_vdi.h" +#include "sensor_trace.h" namespace OHOS { namespace HDI { diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index 78e250578e..43a09d521f 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -24,6 +24,7 @@ #include "sensor_type.h" #include "sensor_callback_impl.h" #include "sensor_uhdf_log.h" +#include "sensor_trace.h" using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; @@ -82,7 +83,7 @@ namespace { constexpr int64_t SENSOR_INTERVAL4 = 20000000; constexpr int32_t SENSOR_POLL_TIME = 1; constexpr int32_t SENSOR_WAIT_TIME = 100; - constexpr int32_t SENSOR_WAIT_TIME2 = 20000; + constexpr int32_t SENSOR_WAIT_TIME2 = 1000; constexpr int32_t ABNORMAL_SENSORID = -1; constexpr int32_t RATE_LEVEL = 50; } @@ -610,4 +611,47 @@ HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0003, TestSize.Level1) EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, 1); SensorCallbackImpl::sensorDataFlag = 1; +} + +/** + * @tc.name: SetSdcSensor + * @tc.desc: Read event data for the specified sensor. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorHdiTest, SetSdcSensor, TestSize.Level1) +{ + SENSOR_TRACE; + ASSERT_NE(nullptr, g_sensorInterface); + + EXPECT_GT(g_info.size(), 0); + for (auto iter : g_info) { + int32_t ret = g_sensorInterface->SetSdcSensor(iter.sensorId, true, RATE_LEVEL); + EXPECT_EQ(SENSOR_SUCCESS, ret); + int32_t ret = g_sensorInterface->Disable(iter.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + ret = g_sensorInterface->SetSdcSensor(iter.sensorId, false, RATE_LEVEL); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } +} + +/** + * @tc.name: EnableButUnregisterTest + * @tc.desc: Read event data for the specified sensor. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorHdiTest, EnableButUnregisterTest, TestSize.Level1) +{ + SENSOR_TRACE; + ASSERT_NE(nullptr, g_sensorInterface); + + + int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); + EXPECT_GT(g_info.size(), 0); + for (auto iter : g_info) { + int32_t ret = g_sensorInterface->Enable(iter.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } } \ No newline at end of file -- Gitee From 48af90b8996ad562303dfaf215e9e9ea97badf6d Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 13 Aug 2024 04:49:29 +0000 Subject: [PATCH 0152/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c. Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/hdi_wpa_common.c | 4 ++-- .../interfaces/hdi_service/service_common/wpa_common_cmd.c | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index 65e5660f12..6904c30529 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -289,9 +289,9 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) int nameLen = strlen(ifName); ReleaseIfaceCtrl(ifName, nameLen); } - if (ret == 0 && ifName != NULL && - strncmp(cmd, "TERMINATE ", strlen("TERMINATE ")) == 0) { + if (strncmp(cmd, "TERMINATE ", strlen("TERMINATE ")) == 0) { ReleaseWpaGlobalInterface(); + HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); } pthread_mutex_unlock(&g_mutexWpa); return ret; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 1c703cfa90..093a97e172 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -2065,7 +2065,6 @@ static int32_t StopWpaSupplicant(void) } else { HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); } - HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); return HDF_SUCCESS; } -- Gitee From 5646547283653c4e39b72fd8638f825cb3549226 Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Tue, 13 Aug 2024 03:30:20 +0000 Subject: [PATCH 0153/1485] emulator modify Signed-off-by: yuzhiqiang --- usb/ddk/host/src/usb_pnp_manager.c | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/usb/ddk/host/src/usb_pnp_manager.c b/usb/ddk/host/src/usb_pnp_manager.c index 4ed5cbb355..318e84a1fb 100644 --- a/usb/ddk/host/src/usb_pnp_manager.c +++ b/usb/ddk/host/src/usb_pnp_manager.c @@ -161,6 +161,16 @@ static int32_t UsbPnpManagerInit(struct HdfDeviceObject *device) return HDF_FAILURE; } #endif + +#ifdef USB_EMULATOR_MODE + ret = UsbDdkPnpLoaderEventHandle(); + if (ret != HDF_SUCCESS) { + HDF_LOGW("%{public}s: emulator, UsbDdkPnpLoaderEventHandle failed", __func__); + } + if (DdkListenerMgrAdd(&usbPnpListener) != HDF_SUCCESS) { + HDF_LOGW("%{public}s: emulator, add listener failed", __func__); + } +#else ret = UsbDdkPnpLoaderEventHandle(); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: UsbDdkPnpLoaderEventHandle failed", __func__); @@ -170,6 +180,7 @@ static int32_t UsbPnpManagerInit(struct HdfDeviceObject *device) HDF_LOGE("%{public}s: add listener failed", __func__); return HDF_FAILURE; } +#endif HDF_LOGI("UsbPnpManagerInit done"); return HDF_SUCCESS; } -- Gitee From a4edb54906414bbbb9dab6269cad4f93c7b9c129 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Tue, 13 Aug 2024 06:13:56 +0000 Subject: [PATCH 0154/1485] update audio/bundle.json. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/bundle.json | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/audio/bundle.json b/audio/bundle.json index 073aa25e6e..0a2cab38d1 100755 --- a/audio/bundle.json +++ b/audio/bundle.json @@ -47,16 +47,15 @@ "build": { "sub_component": [ "//drivers/peripheral/audio:hdi_audio", - "//drivers/peripheral/audio/effect:effect_model" + "//drivers/peripheral/audio/effect:effect_model", + "//drivers/peripheral/audio:libaudio_header_static" ], "inner_kits": [ { - "type": "so", - "name": "//drivers/peripheral/audio/hdi_service/primary_impl:audio_primary_impl_vendor", + "name": "//drivers/peripheral/audio:libaudio_header_static", "header": { "header_base": "//drivers/peripheral/audio/interfaces/sound", - "header_files": [ - ] + "header_files": [] } } ], -- Gitee From 4b2a02c5f34eed44e8feee648d960b608f218693 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Tue, 13 Aug 2024 06:17:23 +0000 Subject: [PATCH 0155/1485] update audio/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/BUILD.gn | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/audio/BUILD.gn b/audio/BUILD.gn index d014f1729c..d3b262351f 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -25,3 +25,14 @@ group("hdi_audio") { deps += [ "hdi_service:idl_audio" ] } } + +config("drivers_peripheral_audio_header") { + include_dirs = [ "interfaces/sound" ] +} + +ohos_static_library("libaudio_header_static") { + public_configs = [ ":drivers_peripheral_audio_header" ] + + part_name = "drivers_peripheral_audio" + subsystem_name = "hdf" +} -- Gitee From aa0248e972e8e27511b893e23975a81f50b5c219 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Tue, 13 Aug 2024 06:17:48 +0000 Subject: [PATCH 0156/1485] update audio/hdi_service/primary_impl/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/BUILD.gn | 5 ----- 1 file changed, 5 deletions(-) diff --git a/audio/hdi_service/primary_impl/BUILD.gn b/audio/hdi_service/primary_impl/BUILD.gn index 7c7c7d84a1..2d86a99dfb 100644 --- a/audio/hdi_service/primary_impl/BUILD.gn +++ b/audio/hdi_service/primary_impl/BUILD.gn @@ -16,10 +16,6 @@ hdf_hdi_service_path = "./.." import("//build/ohos.gni") import("$hdf_audio_path/audio.gni") -config("drivers_peripheral_audio_header") { - include_dirs = [ "//drivers/peripheral/audio/interfaces/sound" ] -} - ohos_shared_library("audio_primary_impl_vendor") { defines = [] if (drivers_peripheral_audio_feature_community) { @@ -94,7 +90,6 @@ ohos_shared_library("audio_primary_impl_vendor") { defines += [ "AUDIO_HICOLLIE_ENABLE" ] } - public_configs = [ ":drivers_peripheral_audio_header" ] install_images = [ chipset_base_dir ] subsystem_name = "hdf" part_name = "drivers_peripheral_audio" -- Gitee From cd55d14864081bef3ef3890af455ff92cf81c37f Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 06:30:59 +0000 Subject: [PATCH 0157/1485] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=BA=BF=E7=A8=8B?= =?UTF-8?q?=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/include/input_device_manager.h | 2 -- input/udriver/src/input_device_manager.cpp | 18 +++++++++--------- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/input/udriver/include/input_device_manager.h b/input/udriver/include/input_device_manager.h index 6447ecbef3..3290ed4b68 100644 --- a/input/udriver/include/input_device_manager.h +++ b/input/udriver/include/input_device_manager.h @@ -137,8 +137,6 @@ private: mutable std::mutex lock_; std::mutex reportEventPkgCallBackLock_; - std::mutex reportHotPlugEventCallBackLock_; - std::mutex inputDevListLock_; std::map inputDevList_; struct epoll_event epollEventList_[EPOLL_MAX_EVENTS] {}; std::string devPath_ {"/dev/input"}; diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index 5c4c3da4ed..cb19f62ac1 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -44,7 +44,9 @@ constexpr uint32_t DEV_INDEX_MAX = 32; void InputDeviceManager::Init() { inputDevList_.clear(); + reportEventPkgCallBackLock_.lock(); reportEventPkgCallback_.clear(); + reportEventPkgCallBackLock_.unlock(); GetInputDeviceInfoList(); std::thread t1([this] {this->WorkerThread();}); std::string wholeName1 = std::to_string(getpid()) + "_" + std::to_string(gettid()); @@ -100,6 +102,8 @@ void InputDeviceManager::ReportEventPkg(int32_t iFd, InputEventPackage **iEvtPkg HDF_LOGE("%{public}s: param invalid, line: %{public}d", __func__, __LINE__); return; } + + std::lock_guard guard(reportEventPkgCallBackLock_); for (auto &callbackFunc : reportEventPkgCallback_) { uint32_t index {0}; auto ret = FindIndexFromFd(iFd, &index); @@ -271,7 +275,7 @@ uint32_t GetInputDeviceTypeInfo(const string &devName) void InputDeviceManager::GetInputDeviceInfoList(int32_t epollFd) { - std::lock_guard guard(inputDevListLock_); + std::lock_guard guard(lock_); inputDevList_.clear(); std::vector flist = GetFiles(devPath_); std::shared_ptr detailInfo; @@ -351,7 +355,6 @@ int32_t InputDeviceManager::DoInputDeviceAction(void) void InputDeviceManager::DeleteDevListNode(int index) { - std::lock_guard guard(inputDevListLock_); for (auto it = inputDevList_.begin(); it != inputDevList_.end();) { if (it->first == (uint32_t)index) { it = inputDevList_.erase(it); @@ -369,7 +372,6 @@ void InputDeviceManager::DeleteDevListNode(int index) int32_t InputDeviceManager::AddDeviceNodeToList( int32_t &epollFd, int32_t &fd, string devPath, std::shared_ptr &detailInfo) { - std::lock_guard guard(inputDevListLock_); if (epollFd < 0 || fd < 0) { HDF_LOGE("%{public}s: param invalid, %{public}d", __func__, __LINE__); return INPUT_FAILURE; @@ -401,7 +403,6 @@ void InputDeviceManager::DoWithEventDeviceAdd(int32_t &epollFd, int32_t &fd, str uint32_t type {}; uint32_t index {}; uint32_t status {}; - std::shared_ptr detailInfo = std::make_shared(); (void)memset_s(detailInfo.get(), sizeof(InputDeviceInfo), 0, sizeof(InputDeviceInfo)); (void)GetInputDeviceInfo(fd, detailInfo.get()); @@ -464,7 +465,7 @@ void InputDeviceManager::DoWithEventDeviceDel(int32_t &epollFd, uint32_t &index) HDF_LOGD("%{public}s: index: %{public}d fd: %{public}d devName: %{public}s", __func__, index, inputDevList_[index].fd, inputDevList_[index].detailInfo.attrSet.devName); - + // hot plug evnets happened auto sDevName = string(inputDevList_[index].detailInfo.attrSet.devName); if (sDevName.find("Keyboard") != std::string::npos) { @@ -571,6 +572,7 @@ int32_t InputDeviceManager::FindIndexFromDevName(string devName, uint32_t *index // InputManager RetStatus InputDeviceManager::ScanDevice(InputDevDesc *staArr, uint32_t arrLen) { + std::lock_guard guard(lock_); if (staArr == nullptr) { HDF_LOGE("%{public}s: param is null", __func__); return INPUT_NULL_PTR; @@ -822,32 +824,31 @@ RetStatus InputDeviceManager::RunExtraCommand(uint32_t devIndex, InputExtraCmd * // InputReporter RetStatus InputDeviceManager::RegisterReportCallback(uint32_t devIndex, InputEventCb *callback) { - std::lock_guard guard(reportEventPkgCallBackLock_); RetStatus rc = INPUT_SUCCESS; if ((devIndex >= inputDevList_.size()) || (callback == nullptr) || (callback->EventPkgCallback == nullptr)) { HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } + std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = callback; return rc; } RetStatus InputDeviceManager::UnregisterReportCallback(uint32_t devIndex) { - std::lock_guard guard(reportEventPkgCallBackLock_); HDF_LOGI("%{public}s: %{public}d dev is unregister", __func__, devIndex); RetStatus rc = INPUT_SUCCESS; if (devIndex >= inputDevList_.size()) { HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } + std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = nullptr; return rc; } RetStatus InputDeviceManager::RegisterHotPlugCallback(InputHostCb *callback) { - std::lock_guard guard(reportHotPlugEventCallBackLock_); RetStatus rc = INPUT_SUCCESS; reportHotPlugEventCallback_ = callback; HDF_LOGI("%{public}s: called line %{public}d ret %{public}d", __func__, __LINE__, rc); @@ -856,7 +857,6 @@ RetStatus InputDeviceManager::RegisterHotPlugCallback(InputHostCb *callback) RetStatus InputDeviceManager::UnregisterHotPlugCallback(void) { - std::lock_guard guard(reportHotPlugEventCallBackLock_); RetStatus rc = INPUT_SUCCESS; reportHotPlugEventCallback_ = nullptr; HDF_LOGI("%{public}s: called line %{public}d ret:%{public}d", __func__, __LINE__, rc); -- Gitee From 1c3156652912540fcc0fbdcd4ce58b51fe841dc5 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 06:33:43 +0000 Subject: [PATCH 0158/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=9B=9E=E9=80=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/src/input_device_manager.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index cb19f62ac1..264a40a4e4 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -275,7 +275,6 @@ uint32_t GetInputDeviceTypeInfo(const string &devName) void InputDeviceManager::GetInputDeviceInfoList(int32_t epollFd) { - std::lock_guard guard(lock_); inputDevList_.clear(); std::vector flist = GetFiles(devPath_); std::shared_ptr detailInfo; @@ -572,7 +571,6 @@ int32_t InputDeviceManager::FindIndexFromDevName(string devName, uint32_t *index // InputManager RetStatus InputDeviceManager::ScanDevice(InputDevDesc *staArr, uint32_t arrLen) { - std::lock_guard guard(lock_); if (staArr == nullptr) { HDF_LOGE("%{public}s: param is null", __func__); return INPUT_NULL_PTR; -- Gitee From 1bdf7c0c834a65ec5ef13ebb396391122e497143 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 06:35:07 +0000 Subject: [PATCH 0159/1485] =?UTF-8?q?=E5=88=A0=E9=99=A4=E7=A9=BA=E6=A0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/src/input_device_manager.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index 264a40a4e4..3c5e92f523 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -403,6 +403,7 @@ void InputDeviceManager::DoWithEventDeviceAdd(int32_t &epollFd, int32_t &fd, str uint32_t index {}; uint32_t status {}; std::shared_ptr detailInfo = std::make_shared(); + (void)memset_s(detailInfo.get(), sizeof(InputDeviceInfo), 0, sizeof(InputDeviceInfo)); (void)GetInputDeviceInfo(fd, detailInfo.get()); auto sDevName = string(detailInfo->attrSet.devName); @@ -464,7 +465,7 @@ void InputDeviceManager::DoWithEventDeviceDel(int32_t &epollFd, uint32_t &index) HDF_LOGD("%{public}s: index: %{public}d fd: %{public}d devName: %{public}s", __func__, index, inputDevList_[index].fd, inputDevList_[index].detailInfo.attrSet.devName); - + // hot plug evnets happened auto sDevName = string(inputDevList_[index].detailInfo.attrSet.devName); if (sDevName.find("Keyboard") != std::string::npos) { -- Gitee From dc4a36a1179be002e554a13c4b436ab939443941 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 13 Aug 2024 06:35:41 +0000 Subject: [PATCH 0160/1485] =?UTF-8?q?=E5=88=A0=E9=99=A4=E7=A9=BA=E8=A1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/src/input_device_manager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index 3c5e92f523..b071443dbd 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -402,8 +402,8 @@ void InputDeviceManager::DoWithEventDeviceAdd(int32_t &epollFd, int32_t &fd, str uint32_t type {}; uint32_t index {}; uint32_t status {}; - std::shared_ptr detailInfo = std::make_shared(); + std::shared_ptr detailInfo = std::make_shared(); (void)memset_s(detailInfo.get(), sizeof(InputDeviceInfo), 0, sizeof(InputDeviceInfo)); (void)GetInputDeviceInfo(fd, detailInfo.get()); auto sDevName = string(detailInfo->attrSet.devName); -- Gitee From 28462b4f9c118710e02ae7e1c9f2950d03457c31 Mon Sep 17 00:00:00 2001 From: lvqiang214 Date: Tue, 13 Aug 2024 16:55:38 +0800 Subject: [PATCH 0161/1485] domain id fix Signed-off-by: lvqiang214 --- intelligent_voice/utils/intell_voice_log.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/intelligent_voice/utils/intell_voice_log.h b/intelligent_voice/utils/intell_voice_log.h index 6bdd6a8530..15100d34ff 100755 --- a/intelligent_voice/utils/intell_voice_log.h +++ b/intelligent_voice/utils/intell_voice_log.h @@ -18,6 +18,9 @@ #include #include "hdf_log.h" +#undef LOG_DOMAIN +#define LOG_DOMAIN 0xD002561 + #define INTELLIGENT_VOICE_LOGD(fmt, arg...) \ do { \ HDF_LOGD("[%{public}s][line:%{public}d]: " fmt, __func__, __LINE__, ##arg); \ -- Gitee From 6c704c946a216e6a9d8f45223466bdc944f58fcd Mon Sep 17 00:00:00 2001 From: chenjunwu Date: Tue, 13 Aug 2024 17:21:31 +0800 Subject: [PATCH 0162/1485] fix: add mutex_ for concurrent operations map Signed-off-by: chenjunwu --- .../hdi_service/include/power_supply_provider.h | 2 ++ .../hdi_service/src/power_supply_provider.cpp | 15 +++++++++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/battery/interfaces/hdi_service/include/power_supply_provider.h b/battery/interfaces/hdi_service/include/power_supply_provider.h index 840d79cde6..f6c11344f8 100644 --- a/battery/interfaces/hdi_service/include/power_supply_provider.h +++ b/battery/interfaces/hdi_service/include/power_supply_provider.h @@ -21,6 +21,7 @@ #include #include #include +#include #include "batteryd_api.h" #include "v2_0/ibattery_interface.h" @@ -161,6 +162,7 @@ private: std::map nodeCacheFiles_; std::string path_; int32_t index_; + std::mutex mutex_; }; } // namespace V2_0 } // namespace Battery diff --git a/battery/interfaces/hdi_service/src/power_supply_provider.cpp b/battery/interfaces/hdi_service/src/power_supply_provider.cpp index 5394806567..7ee4b2b424 100644 --- a/battery/interfaces/hdi_service/src/power_supply_provider.cpp +++ b/battery/interfaces/hdi_service/src/power_supply_provider.cpp @@ -77,6 +77,7 @@ PowerSupplyProvider::PowerSupplyProvider() PowerSupplyProvider::~PowerSupplyProvider() { + std::lock_guard lock(mutex_); for (auto it = nodeCacheFiles_.begin(); it != nodeCacheFiles_.end();) { int32_t fd = it->second; close(fd); @@ -280,9 +281,12 @@ int32_t PowerSupplyProvider::ReadSysfsFile(const char* path, char* buf, size_t s { int32_t fd = -1; - auto item = nodeCacheFiles_.find(path); - if (item != nodeCacheFiles_.end()) { - fd = item->second; + { + std::lock_guard lock(mutex_); + auto item = nodeCacheFiles_.find(path); + if (item != nodeCacheFiles_.end()) { + fd = item->second; + } } if (fd != -1) { @@ -301,7 +305,10 @@ int32_t PowerSupplyProvider::ReadSysfsFile(const char* path, char* buf, size_t s size_t readSize = read(fd, buf, size - 1); buf[readSize] = '\0'; Trim(buf); - nodeCacheFiles_.insert(std::make_pair(path, fd)); + { + std::lock_guard lock(mutex_); + nodeCacheFiles_.insert(std::make_pair(path, fd)); + } return HDF_SUCCESS; } -- Gitee From de885f2f4fe9ccc92205ec03797082b6bfb7a55a Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 13 Aug 2024 07:51:35 +0000 Subject: [PATCH 0163/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c | 2 +- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index 6904c30529..a32421b5ec 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -289,7 +289,7 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) int nameLen = strlen(ifName); ReleaseIfaceCtrl(ifName, nameLen); } - if (strncmp(cmd, "TERMINATE ", strlen("TERMINATE ")) == 0) { + if (strncmp(cmd, "TERMINATE", strlen("TERMINATE")) == 0) { ReleaseWpaGlobalInterface(); HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); } diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index f3c6b1a4a3..7b5e50542a 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -25,6 +25,7 @@ #include "wpa_client.h" #endif + #undef LOG_TAG #define LOG_TAG "HdiWpaHal" -- Gitee From df1e4125a058514997057495c5deaeea70aa2f30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 17:43:16 +0800 Subject: [PATCH 0164/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_client_info.cpp | 1 - sensor/hdi_service/sensor_client_info.h | 1 - 2 files changed, 2 deletions(-) diff --git a/sensor/hdi_service/sensor_client_info.cpp b/sensor/hdi_service/sensor_client_info.cpp index 6a332c8636..76efe3d6cf 100644 --- a/sensor/hdi_service/sensor_client_info.cpp +++ b/sensor/hdi_service/sensor_client_info.cpp @@ -36,7 +36,6 @@ SensorClientInfo::~SensorClientInfo() void SensorClientInfo::SetReportDataCb(const sptr &callbackObj) { - SENSOR_TRACE_PID; pollCallback_ = callbackObj; } diff --git a/sensor/hdi_service/sensor_client_info.h b/sensor/hdi_service/sensor_client_info.h index dba3517cd1..c5615b6206 100644 --- a/sensor/hdi_service/sensor_client_info.h +++ b/sensor/hdi_service/sensor_client_info.h @@ -20,7 +20,6 @@ #include #include "v2_0/isensor_interface.h" #include "isensor_interface_vdi.h" -#include "sensor_trace.h" namespace OHOS { namespace HDI { -- Gitee From ee0432270b198bf1fc4c0c303ddc0845a05edbbe Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 13 Aug 2024 09:46:47 +0000 Subject: [PATCH 0165/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/hdi_wpa_hal.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index 7b5e50542a..cc7c9850d5 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -25,7 +25,6 @@ #include "wpa_client.h" #endif - #undef LOG_TAG #define LOG_TAG "HdiWpaHal" @@ -202,14 +201,18 @@ static int WpaCliRemoveIface(WifiWpaInterface *p, const char *name) static int WpaCliWpaTerminate(void) { + pthread_mutex_lock(&g_mutex); HDF_LOGI("enter WpaCliWpaTerminate."); char cmd[WPA_CMD_BUF_LEN] = {0}; char buf[WPA_CMD_REPLY_BUF_SMALL_LEN] = {0}; if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "TERMINATE") < 0) { HDF_LOGE("WpaCliWpaTerminate, snprintf err"); + pthread_mutex_unlock(&g_mutex); return -1; } - return WpaCliCmd(cmd, buf, sizeof(buf)); + int ret = WpaCliCmd(cmd, buf, sizeof(buf)); + pthread_mutex_unlock(&g_mutex); + return ret; } WifiWpaInterface *GetWifiWpaGlobalInterface(void) @@ -239,11 +242,8 @@ WifiWpaInterface *GetWifiWpaGlobalInterface(void) void ReleaseWpaGlobalInterface(void) { - pthread_mutex_lock(&g_mutex); - HDF_LOGI("enter ReleaseWpaGlobalInterface."); if (g_wpaInterface == NULL) { - pthread_mutex_unlock(&g_mutex); return; } WpaIfaceInfo *p = g_wpaInterface->ifaces; @@ -255,7 +255,6 @@ void ReleaseWpaGlobalInterface(void) WpaCliClose(g_wpaInterface); free(g_wpaInterface); g_wpaInterface = NULL; - pthread_mutex_unlock(&g_mutex); } WpaCtrl *GetStaCtrl(void) -- Gitee From 4c42f16e9fddb577fb3c506809befa4d9bd8ad06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 17:52:52 +0800 Subject: [PATCH 0166/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/sensor/test/unittest/hdi/BUILD.gn b/sensor/test/unittest/hdi/BUILD.gn index 0d07bd127b..3a894c4591 100644 --- a/sensor/test/unittest/hdi/BUILD.gn +++ b/sensor/test/unittest/hdi/BUILD.gn @@ -44,6 +44,7 @@ ohos_unittest("hdi_unittest_sensor") { "drivers_interface_sensor:libsensor_proxy_2.0", "hdf_core:libhdf_utils", "hilog:libhilog", + "hitrace:hitrace_meter", "ipc:ipc_single", ] if (c_utils_enable) { -- Gitee From 0ce7dc038a488aa4974aba885fd42486eb61f806 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 17:55:22 +0800 Subject: [PATCH 0167/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index 43a09d521f..873a030a94 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -614,12 +614,12 @@ HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0003, TestSize.Level1) } /** - * @tc.name: SetSdcSensor + * @tc.name: SetSdcSensor_001 * @tc.desc: Read event data for the specified sensor. * @tc.type: FUNC * @tc.require: #I4L3LF */ -HWTEST_F(HdfSensorHdiTest, SetSdcSensor, TestSize.Level1) +HWTEST_F(HdfSensorHdiTest, SetSdcSensor_001, TestSize.Level1) { SENSOR_TRACE; ASSERT_NE(nullptr, g_sensorInterface); -- Gitee From 0557cd4b251c76fef55ea83a49ec78d9bf17c46a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 17:56:16 +0800 Subject: [PATCH 0168/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index 873a030a94..db479e7398 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -623,12 +623,12 @@ HWTEST_F(HdfSensorHdiTest, SetSdcSensor_001, TestSize.Level1) { SENSOR_TRACE; ASSERT_NE(nullptr, g_sensorInterface); - + int32_t ret; EXPECT_GT(g_info.size(), 0); for (auto iter : g_info) { - int32_t ret = g_sensorInterface->SetSdcSensor(iter.sensorId, true, RATE_LEVEL); + ret = g_sensorInterface->SetSdcSensor(iter.sensorId, true, RATE_LEVEL); EXPECT_EQ(SENSOR_SUCCESS, ret); - int32_t ret = g_sensorInterface->Disable(iter.sensorId); + ret = g_sensorInterface->Disable(iter.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); ret = g_sensorInterface->SetSdcSensor(iter.sensorId, false, RATE_LEVEL); EXPECT_EQ(SENSOR_SUCCESS, ret); -- Gitee From 46b212640d4c3aff6eaed710d58d38fd756ebf99 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 18:04:07 +0800 Subject: [PATCH 0169/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp index 845a0834eb..a541ee4d12 100644 --- a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp +++ b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp @@ -682,9 +682,9 @@ HWTEST_F(HdfVibratorHdiTest, StopTest, TestSize.Level1) OsalMSleep(g_sleepTime1); - int32_t startRet = g_vibratorInterface->Start(g_effect1); + startRet = g_vibratorInterface->Start(g_effect1); EXPECT_EQ(startRet, HDF_SUCCESS); - int32_t endRet = g_vibratorInterface->Stop(HdfVibratorMode::HDF_VIBRATOR_MODE_BUTT); + endRet = g_vibratorInterface->Stop(HdfVibratorMode::HDF_VIBRATOR_MODE_BUTT); EXPECT_EQ(endRet, HDF_ERR_INVALID_PARAM); OsalMSleep(g_sleepTime1); } @@ -701,6 +701,6 @@ HWTEST_F(HdfVibratorHdiTest, GetAllWaveInfoTest, TestSize.Level1) HDF_LOGI("StartByIntensityTest in"); ASSERT_NE(nullptr, g_vibratorInterface); - int32_t endRet = g_vibratorInterface->GetAllWaveInfo(g_vibratorId, g_info); + int32_t startRet = g_vibratorInterface->GetAllWaveInfo(g_vibratorId, g_info); EXPECT_EQ(startRet, HDF_SUCCESS); } \ No newline at end of file -- Gitee From c83596dd3e7799767c753bee68ad243d1d01e84a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 18:19:29 +0800 Subject: [PATCH 0170/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index db479e7398..a297e23532 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -228,7 +228,7 @@ HWTEST_F(HdfSensorHdiTest, EnableSensor0001, TestSize.Level1) EXPECT_EQ(SENSOR_SUCCESS, ret); ret = g_sensorInterface->Enable(iter.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); - OsalSleep(SENSOR_POLL_TIME); + OsalMSleep(SENSOR_WAIT_TIME); ret = g_sensorInterface->Disable(iter.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); } @@ -654,4 +654,11 @@ HWTEST_F(HdfSensorHdiTest, EnableButUnregisterTest, TestSize.Level1) int32_t ret = g_sensorInterface->Enable(iter.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); } + ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); + OsalMSleep(SENSOR_WAIT_TIME2); + for (auto iter : g_info) { + int32_t ret = g_sensorInterface->Disable(iter.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } } \ No newline at end of file -- Gitee From f0c67b2cdcee0bf8fb3cda2fe09100489209f7e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 18:40:07 +0800 Subject: [PATCH 0171/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../include/sensor_callback_impl_test.h | 76 +++++++++++++++++++ .../common/src/sensor_callback_impl_test.cpp | 36 +++++++++ 2 files changed, 112 insertions(+) create mode 100644 sensor/test/common/include/sensor_callback_impl_test.h create mode 100644 sensor/test/common/src/sensor_callback_impl_test.cpp diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h new file mode 100644 index 0000000000..d50b8ef844 --- /dev/null +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HDI_SENSOR_V2_0_SENSORCALLBACKIMPLTEST_H +#define OHOS_HDI_SENSOR_V2_0_SENSORCALLBACKIMPLTEST_H + +#include +#include "v2_0/isensor_callback.h" + +namespace OHOS { +namespace HDI { +namespace Sensor { +namespace V2_0 { +class SensorCallbackImplTest : public ISensorCallback { +public: + virtual ~SensorCallbackImpl() {} + + int32_t OnDataEvent(const HdfSensorEvents& event) override; + + void PrintData(const HdfSensorEvents &event) + { + std::string st = {0}; + DataToStr(st, event); + HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); + } + + void DataToStr(std::string &str, const HdfSensorEvents &event) + { + void *origin = OsalMemCalloc(sizeof(uint8_t) * (event.dataLen)); + if (origin == nullptr) { + HDF_LOGE("%{public}s: OsalMemCalloc failed", __func__); + return; + } + + uint8_t *eventData = static_cast(origin); + std::copy(event.data.begin(), event.data.end(), eventData); + float *data = reinterpret_cast(eventData); + int32_t dataLen = event.dataLen; + int32_t dataDimension = static_cast(dataLen / sizeof(float)); + std::string dataStr = {0}; + char arrayStr[DATA_LEN] = {0}; + + for (int32_t i = 0; i < dataDimension; i++) { + if (sprintf_s(arrayStr + strlen(arrayStr), DATA_LEN, "[%f]", data[i]) < 0) { + HDF_LOGE("%{public}s: sprintf_s failed", __func__); + OsalMemFree(origin); + return; + } + } + + dataStr = arrayStr; + str = "sensorId: " + std::to_string(event.sensorId) + ", ts: " + + std::to_string(event.timestamp) + ", data: " + dataStr; + + OsalMemFree(origin); + return; + } +}; +} // V2_0 +} // Sensor +} // HDI +} // OHOS + +#endif // OHOS_HDI_SENSOR_V2_0_SENSORCALLBACKIMPLTEST_H diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp new file mode 100644 index 0000000000..af4bdae2fb --- /dev/null +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include + +#include "osal_mem.h" +#include "sensor_callback_impl.h" +#include "sensor_type.h" +#include "hdf_log.h" + +namespace OHOS { +namespace HDI { +namespace Sensor { +namespace V2_0 { +namespace { +int32_t SensorCallbackImplTest::OnDataEvent(const HdfSensorEvents& event) +{ + PrintData(event); + return HDF_FAILURE; +} +} +} // V2_0 +} // Sensor +} // HDI +} // OHOS -- Gitee From 43d97b6b1bb3b6c753e368c6402e570d230947e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 18:57:35 +0800 Subject: [PATCH 0172/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../test/unittest/hdi/hdf_sensor_hdi_test.cpp | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index a297e23532..af6cbf1506 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -23,6 +23,7 @@ #include "v2_0/isensor_interface.h" #include "sensor_type.h" #include "sensor_callback_impl.h" +#include "sensor_callback_impl_test.h" #include "sensor_uhdf_log.h" #include "sensor_trace.h" @@ -32,6 +33,7 @@ using namespace testing::ext; namespace { sptr g_sensorInterface = nullptr; sptr g_traditionalCallback = new SensorCallbackImpl(); + sptr g_traditionalCallbackTest = new SensorCallbackImplTest(); sptr g_medicalCallback = new SensorCallbackImpl(); std::vector g_info; std::vector g_events; @@ -661,4 +663,32 @@ HWTEST_F(HdfSensorHdiTest, EnableButUnregisterTest, TestSize.Level1) int32_t ret = g_sensorInterface->Disable(iter.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); } +} + +/** + * @tc.name: SensorCallbackImplFailureTest + * @tc.desc: Read event data for the specified sensor. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorHdiTest, SensorCallbackImplFailureTest, TestSize.Level1) +{ + SENSOR_TRACE; + ASSERT_NE(nullptr, g_sensorInterface); + + + int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallbackTest); + EXPECT_EQ(SENSOR_SUCCESS, ret); + EXPECT_GT(g_info.size(), 0); + for (auto iter : g_info) { + int32_t ret = g_sensorInterface->Enable(iter.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } + OsalMSleep(SENSOR_WAIT_TIME2); + for (auto iter : g_info) { + int32_t ret = g_sensorInterface->Disable(iter.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } + ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); } \ No newline at end of file -- Gitee From db6870b3230265de8d3ae460ebce159db790c7fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:21:38 +0800 Subject: [PATCH 0173/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/sensor/test/unittest/hdi/BUILD.gn b/sensor/test/unittest/hdi/BUILD.gn index 3a894c4591..268d4b62a4 100644 --- a/sensor/test/unittest/hdi/BUILD.gn +++ b/sensor/test/unittest/hdi/BUILD.gn @@ -29,6 +29,7 @@ ohos_unittest("hdi_unittest_sensor") { sources = [ "../../common/src/sensor_callback_impl.cpp", "hdf_sensor_hdi_test.cpp", + "sensor_callback_impl_test.cpp", ] cflags = [ "-Wall", -- Gitee From 0adee1b2d62063522fe014bb46782ca070e8f43e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:27:33 +0800 Subject: [PATCH 0174/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/hdi/BUILD.gn b/sensor/test/unittest/hdi/BUILD.gn index 268d4b62a4..2146c16376 100644 --- a/sensor/test/unittest/hdi/BUILD.gn +++ b/sensor/test/unittest/hdi/BUILD.gn @@ -28,8 +28,8 @@ ohos_unittest("hdi_unittest_sensor") { sources = [ "../../common/src/sensor_callback_impl.cpp", + "../../common/src/sensor_callback_impl_test.cpp", "hdf_sensor_hdi_test.cpp", - "sensor_callback_impl_test.cpp", ] cflags = [ "-Wall", -- Gitee From 0ec6f6555524f51d914b9cab67109ede290bc313 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:30:21 +0800 Subject: [PATCH 0175/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/include/sensor_callback_impl_test.h | 1 + sensor/test/common/src/sensor_callback_impl_test.cpp | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h index d50b8ef844..0edaeaf97b 100644 --- a/sensor/test/common/include/sensor_callback_impl_test.h +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -18,6 +18,7 @@ #include #include "v2_0/isensor_callback.h" +#include "hdf_log.h" namespace OHOS { namespace HDI { diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index af4bdae2fb..1f3511f575 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -17,7 +17,6 @@ #include "osal_mem.h" #include "sensor_callback_impl.h" #include "sensor_type.h" -#include "hdf_log.h" namespace OHOS { namespace HDI { -- Gitee From df67d77630b1364ede982c7b8bceb0bc7027d1a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:40:21 +0800 Subject: [PATCH 0176/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/include/sensor_callback_impl_test.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h index 0edaeaf97b..d391e6aceb 100644 --- a/sensor/test/common/include/sensor_callback_impl_test.h +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -19,14 +19,18 @@ #include #include "v2_0/isensor_callback.h" #include "hdf_log.h" +#include "osal_mem.h" namespace OHOS { namespace HDI { namespace Sensor { namespace V2_0 { + +constexpr int32_t DATA_LEN = 256; + class SensorCallbackImplTest : public ISensorCallback { public: - virtual ~SensorCallbackImpl() {} + virtual ~SensorCallbackImplTest() {} int32_t OnDataEvent(const HdfSensorEvents& event) override; -- Gitee From d4b8fc329d4eb483584df14990dc4ee18efd61a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:41:10 +0800 Subject: [PATCH 0177/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/src/sensor_callback_impl_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 1f3511f575..17a0f9077b 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -15,7 +15,7 @@ #include #include "osal_mem.h" -#include "sensor_callback_impl.h" +#include "sensor_callback_impl_test.h" #include "sensor_type.h" namespace OHOS { -- Gitee From 4dcfa6a18ae7f74551625aebaba4dce3c4205b8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 19:42:50 +0800 Subject: [PATCH 0178/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/src/sensor_callback_impl_test.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 17a0f9077b..5d4face07e 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -22,13 +22,11 @@ namespace OHOS { namespace HDI { namespace Sensor { namespace V2_0 { -namespace { int32_t SensorCallbackImplTest::OnDataEvent(const HdfSensorEvents& event) { PrintData(event); return HDF_FAILURE; } -} } // V2_0 } // Sensor } // HDI -- Gitee From 71c56570bcfab1299d1e057e0823a34cfdcb20a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 20:00:47 +0800 Subject: [PATCH 0179/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp index af6cbf1506..71df162bc2 100644 --- a/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp +++ b/sensor/test/unittest/hdi/hdf_sensor_hdi_test.cpp @@ -624,6 +624,7 @@ HWTEST_F(HdfSensorHdiTest, ReportFrequencyTest0003, TestSize.Level1) HWTEST_F(HdfSensorHdiTest, SetSdcSensor_001, TestSize.Level1) { SENSOR_TRACE; + HDF_LOGI("enter the SetSdcSensor_001 function"); ASSERT_NE(nullptr, g_sensorInterface); int32_t ret; EXPECT_GT(g_info.size(), 0); @@ -647,7 +648,7 @@ HWTEST_F(HdfSensorHdiTest, EnableButUnregisterTest, TestSize.Level1) { SENSOR_TRACE; ASSERT_NE(nullptr, g_sensorInterface); - + HDF_LOGI("enter the EnableButUnregisterTest function"); int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); @@ -675,7 +676,7 @@ HWTEST_F(HdfSensorHdiTest, SensorCallbackImplFailureTest, TestSize.Level1) { SENSOR_TRACE; ASSERT_NE(nullptr, g_sensorInterface); - + HDF_LOGI("enter the SensorCallbackImplFailureTest function"); int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallbackTest); EXPECT_EQ(SENSOR_SUCCESS, ret); -- Gitee From 28902dfff389508411111b1965c9474a1ad4c788 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 20:10:49 +0800 Subject: [PATCH 0180/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/include/sensor_callback_impl_test.h | 2 +- sensor/test/common/src/sensor_callback_impl_test.cpp | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h index d391e6aceb..9b21d970ef 100644 --- a/sensor/test/common/include/sensor_callback_impl_test.h +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -18,7 +18,7 @@ #include #include "v2_0/isensor_callback.h" -#include "hdf_log.h" +#include "sensor_uhdf_log.h" #include "osal_mem.h" namespace OHOS { diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 5d4face07e..9f702a511e 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -24,6 +24,7 @@ namespace Sensor { namespace V2_0 { int32_t SensorCallbackImplTest::OnDataEvent(const HdfSensorEvents& event) { + HDF_LOGD("%{public}s sensorId=%{public}d", __func__, event.sensorId); PrintData(event); return HDF_FAILURE; } -- Gitee From 414da3f0f82e65ddeda4a432d1c0a828884ff256 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 20:12:46 +0800 Subject: [PATCH 0181/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/src/sensor_callback_impl_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 9f702a511e..10edb9a803 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -24,7 +24,7 @@ namespace Sensor { namespace V2_0 { int32_t SensorCallbackImplTest::OnDataEvent(const HdfSensorEvents& event) { - HDF_LOGD("%{public}s sensorId=%{public}d", __func__, event.sensorId); + HDF_LOGI("%{public}s sensorId=%{public}d", __func__, event.sensorId); PrintData(event); return HDF_FAILURE; } -- Gitee From f35e2c2056491684889aa7c83b95e0929dffbd71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 21:35:06 +0800 Subject: [PATCH 0182/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/include/sensor_callback_impl_test.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h index 9b21d970ef..226d0c4e4f 100644 --- a/sensor/test/common/include/sensor_callback_impl_test.h +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -58,7 +58,7 @@ public: char arrayStr[DATA_LEN] = {0}; for (int32_t i = 0; i < dataDimension; i++) { - if (sprintf_s(arrayStr + strlen(arrayStr), DATA_LEN, "[%f]", data[i]) < 0) { + if (snprintf(arrayStr + strlen(arrayStr), DATA_LEN, "[%f]", data[i]) < 0) { HDF_LOGE("%{public}s: sprintf_s failed", __func__); OsalMemFree(origin); return; -- Gitee From 385b1e15d660328213ad87566cb10b10bf78e6c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 13 Aug 2024 22:25:00 +0800 Subject: [PATCH 0183/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../include/sensor_callback_impl_test.h | 40 +------------------ .../common/src/sensor_callback_impl_test.cpp | 2 +- 2 files changed, 2 insertions(+), 40 deletions(-) diff --git a/sensor/test/common/include/sensor_callback_impl_test.h b/sensor/test/common/include/sensor_callback_impl_test.h index 226d0c4e4f..1b6f58bf72 100644 --- a/sensor/test/common/include/sensor_callback_impl_test.h +++ b/sensor/test/common/include/sensor_callback_impl_test.h @@ -17,6 +17,7 @@ #define OHOS_HDI_SENSOR_V2_0_SENSORCALLBACKIMPLTEST_H #include +#include #include "v2_0/isensor_callback.h" #include "sensor_uhdf_log.h" #include "osal_mem.h" @@ -33,45 +34,6 @@ public: virtual ~SensorCallbackImplTest() {} int32_t OnDataEvent(const HdfSensorEvents& event) override; - - void PrintData(const HdfSensorEvents &event) - { - std::string st = {0}; - DataToStr(st, event); - HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); - } - - void DataToStr(std::string &str, const HdfSensorEvents &event) - { - void *origin = OsalMemCalloc(sizeof(uint8_t) * (event.dataLen)); - if (origin == nullptr) { - HDF_LOGE("%{public}s: OsalMemCalloc failed", __func__); - return; - } - - uint8_t *eventData = static_cast(origin); - std::copy(event.data.begin(), event.data.end(), eventData); - float *data = reinterpret_cast(eventData); - int32_t dataLen = event.dataLen; - int32_t dataDimension = static_cast(dataLen / sizeof(float)); - std::string dataStr = {0}; - char arrayStr[DATA_LEN] = {0}; - - for (int32_t i = 0; i < dataDimension; i++) { - if (snprintf(arrayStr + strlen(arrayStr), DATA_LEN, "[%f]", data[i]) < 0) { - HDF_LOGE("%{public}s: sprintf_s failed", __func__); - OsalMemFree(origin); - return; - } - } - - dataStr = arrayStr; - str = "sensorId: " + std::to_string(event.sensorId) + ", ts: " + - std::to_string(event.timestamp) + ", data: " + dataStr; - - OsalMemFree(origin); - return; - } }; } // V2_0 } // Sensor diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 10edb9a803..9dd5bfe815 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -25,7 +25,7 @@ namespace V2_0 { int32_t SensorCallbackImplTest::OnDataEvent(const HdfSensorEvents& event) { HDF_LOGI("%{public}s sensorId=%{public}d", __func__, event.sensorId); - PrintData(event); + (void)event; return HDF_FAILURE; } } // V2_0 -- Gitee From 04092022d812b5e5f9abfb585eb96a8cf7848a06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Wed, 14 Aug 2024 01:33:30 +0000 Subject: [PATCH 0184/1485] update audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c index 9328171310..9b10c305f0 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_adapter_vdi.c @@ -675,7 +675,7 @@ struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAda priv->adapterInfo[descIndex].adapter = adapter; priv->adapterInfo[descIndex].refCnt = 1; priv->adapterInfo[descIndex].adapterName = strdup(adapterName); - if (priv->adapterInfo[descIndex]->adapterName == NULL) { + if (priv->adapterInfo[descIndex].adapterName == NULL) { OsalMemFree((void *)priv->adapterInfo[descIndex].adapter); priv->adapterInfo[descIndex].adapter = NULL; return NULL; -- Gitee From ac3362a8c5b76de4f98e92925b8c326306965929 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 09:48:00 +0800 Subject: [PATCH 0185/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp index a541ee4d12..ee0d07103d 100644 --- a/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp +++ b/vibrator/test/unittest/hdi/hdf_vibrator_hdi_test.cpp @@ -506,12 +506,12 @@ HWTEST_F(HdfVibratorHdiTest, PlayHapticPattern, TestSize.Level1) } /** - * @tc.name: PlayHapticPattern + * @tc.name: PlayHapticPattern_001 * @tc.desc: HD vibration data packet delivery. * @tc.type: FUNC * @tc.require:#I8BZ5H */ -HWTEST_F(HdfVibratorHdiTest, PlayHapticPattern, TestSize.Level1) +HWTEST_F(HdfVibratorHdiTest, PlayHapticPattern_001, TestSize.Level1) { ASSERT_NE(nullptr, g_vibratorInterface); -- Gitee From 5e3330faaa9cd15989de0396704c8f3498dfb34c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 10:09:37 +0800 Subject: [PATCH 0186/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/common/src/sensor_callback_impl_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/common/src/sensor_callback_impl_test.cpp b/sensor/test/common/src/sensor_callback_impl_test.cpp index 9dd5bfe815..5107f83051 100644 --- a/sensor/test/common/src/sensor_callback_impl_test.cpp +++ b/sensor/test/common/src/sensor_callback_impl_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at -- Gitee From 2209f4008721dc017104cbcdf6955f1731320ef8 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 14 Aug 2024 03:03:04 +0000 Subject: [PATCH 0187/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=BB=9D=E5=AF=B9?= =?UTF-8?q?=E8=B7=AF=E5=BE=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal_list.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp b/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp index f10eb78c2d..540869d0ca 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp @@ -26,7 +26,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { -const std::string VENDOR_HAL_PATH = "/vendor/lib64/libwifi_hal_hw.z.so"; +const std::string VENDOR_HAL_PATH = "/libwifi_hal_hw.z.so"; WifiVendorHalList::WifiVendorHalList( const std::weak_ptr ifaceTool) -- Gitee From 0f9b2fdbefd5ea9fd11062697e3d08645a512f4e Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 14 Aug 2024 03:11:03 +0000 Subject: [PATCH 0188/1485] 1 Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal_list.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp b/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp index 540869d0ca..b9e5d4f464 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal_list.cpp @@ -26,7 +26,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { -const std::string VENDOR_HAL_PATH = "/libwifi_hal_hw.z.so"; +const std::string VENDOR_HAL_PATH = "libwifi_hal_hw.z.so"; WifiVendorHalList::WifiVendorHalList( const std::weak_ptr ifaceTool) -- Gitee From 1da0bd7d281d4bab5bc3e56d49b5b522dad68f3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 11:23:23 +0800 Subject: [PATCH 0189/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- OAT.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/OAT.xml b/OAT.xml index 0025b5b709..2039d0d81b 100644 --- a/OAT.xml +++ b/OAT.xml @@ -58,6 +58,7 @@ Note:If the text contains special characters, please escape them according to th + -- Gitee From 8c64a69f2541a9113bb5b2c01a091e5469a22317 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Wed, 14 Aug 2024 03:59:11 +0000 Subject: [PATCH 0190/1485] update audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c index 9001458584..68cabaae4a 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_render_vdi.c @@ -15,6 +15,7 @@ #include "audio_render_vdi.h" +#include #include #include #include "audio_uhdf_log.h" @@ -908,7 +909,7 @@ struct IAudioRender *FindRenderCreated(enum AudioPortPin pin, const struct Audio if ((renderPriv->renderInfos[index] != NULL) && (attrs->type == AUDIO_IN_MEDIA || attrs->type == AUDIO_MULTI_CHANNEL) && (renderPriv->renderInfos[index]->streamType == attrs->type) && - (renderPriv->renderInfos[index]->adapterName == adapterName)) { + (strcmp(renderPriv->renderInfos[index]->adapterName, adapterName) == 0)) { *rendrId = renderPriv->renderInfos[index]->renderId; renderPriv->renderInfos[index]->usrCount++; return &renderPriv->renderInfos[index]->render; -- Gitee From 7dc6a44fae05446d07a5e03df8b51d8f71bb0cf3 Mon Sep 17 00:00:00 2001 From: yangkan Date: Wed, 14 Aug 2024 14:06:46 +0800 Subject: [PATCH 0191/1485] =?UTF-8?q?=E8=A7=A3=E5=86=B3mt=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E8=B7=91=E5=AE=8Ccrash=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangkan --- display/composer/test/moduletest/hdi_device_test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/display/composer/test/moduletest/hdi_device_test.cpp b/display/composer/test/moduletest/hdi_device_test.cpp index 6e635deca9..fbe8379181 100644 --- a/display/composer/test/moduletest/hdi_device_test.cpp +++ b/display/composer/test/moduletest/hdi_device_test.cpp @@ -385,6 +385,7 @@ void DeviceTest::TearDown() void DeviceLayerDisplay::TearDown() { HdiTestDevice::GetInstance().Clear(); + HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer(); } void VblankCtr::NotifyVblank(unsigned int sequence, uint64_t ns, const void* data) -- Gitee From 4262e0327da41921b55d9f82a5e47c02e3a89a13 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 14 Aug 2024 07:37:52 +0000 Subject: [PATCH 0192/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index f12900fc5a..a62a6a1391 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -104,6 +104,7 @@ WifiError WifiVendorHal::Start() void WifiVendorHal::RunEventLoop() { + pthread_setname_np(pthread_self(), "RunEventLoop"); HDF_LOGD("Starting vendor HAL event loop"); globalFuncTable_.startHalLoop(globalHandle_); const auto lock = AcquireGlobalLock(); -- Gitee From 35f63d3a9eed7438f088cb85170287e358cf2e9a Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Wed, 14 Aug 2024 16:43:34 +0800 Subject: [PATCH 0193/1485] commit msg Signed-off-by: xuxuehai --- audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c | 2 +- audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c | 5 ++--- audio/supportlibs/alsa_adapter/src/alsa_snd_render.c | 3 +-- display/buffer/hdi_service/dfx/display_buffer_dfx.cpp | 2 +- display/buffer/hdi_service/dfx/display_buffer_dfx.h | 2 +- 5 files changed, 6 insertions(+), 8 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index 5ca146c97d..a1e49582be 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -351,7 +351,7 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc return AudioIncreaseAdapterRefVdi(descIndex, adapter); } - struct AudioAdapterDescriptorVdi vdiDesc; + struct AudioAdapterDescriptorVdi vdiDesc = {0}; int32_t ret = AudioManagerDescToVdiDesc(desc, &vdiDesc); if (ret != HDF_SUCCESS) { AudioManagerReleaseVdiDesc(&vdiDesc); diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c index 3b99c71e2b..fa431eb633 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_capture.c @@ -381,7 +381,6 @@ int32_t CaptureSetParams(struct AlsaCapture *captureIns, const struct AudioHwCap static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) { - int32_t ret = HDF_SUCCESS; struct AlsaCapture *captureIns = NULL; struct AlsaSoundCard *alsaSnd = NULL; @@ -402,7 +401,7 @@ static struct AlsaCapture *GetCaptureInsByName(const char *adapterName) alsaSnd = (struct AlsaSoundCard *)&g_alsaCaptureList[i]; if (alsaSnd->cardStatus == 0) { (void)memset_s(captureIns, sizeof(struct AlsaCapture), 0, sizeof(struct AlsaCapture)); - ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); + int32_t ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); if (ret != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return NULL; @@ -880,7 +879,7 @@ static int32_t CaptureSetPauseStateImpl(struct AlsaCapture *captureIns, bool pau } cardIns->pauseState = pauseFlag; - return HDF_SUCCESS; + return ret; } static void RegisterCaptureImpl(struct AlsaCapture *captureIns) diff --git a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c index 929e3b05cd..617858c0d4 100755 --- a/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c +++ b/audio/supportlibs/alsa_adapter/src/alsa_snd_render.c @@ -283,7 +283,6 @@ static int32_t ResetRenderParams(struct AlsaSoundCard *cardIns, snd_pcm_access_t static struct AlsaRender *GetRenderInsByName(const char *adapterName) { - int32_t ret = HDF_SUCCESS; struct AlsaRender *renderIns = NULL; struct AlsaSoundCard *alsaSnd = NULL; @@ -304,7 +303,7 @@ static struct AlsaRender *GetRenderInsByName(const char *adapterName) alsaSnd = (struct AlsaSoundCard *)&g_alsaRenderList[i]; if (alsaSnd->cardStatus == 0) { (void)memset_s(renderIns, sizeof(struct AlsaRender), 0, sizeof(struct AlsaRender)); - ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); + int32_t ret = strncpy_s(alsaSnd->adapterName, MAX_CARD_NAME_LEN + 1, adapterName, strlen(adapterName)); if (ret != 0) { AUDIO_FUNC_LOGE("strncpy_s failed!"); return NULL; diff --git a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp index 1a5a6dfacb..4436f32799 100644 --- a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp +++ b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp @@ -25,7 +25,7 @@ namespace HDI { namespace Display { namespace Buffer { namespace V1_0 { -DisplayBufferDfx::DisplayBufferDfx(std::string name) +DisplayBufferDfx::DisplayBufferDfx(const std::string name) : dfxName_(name), timeId_(0), flag_(false), diff --git a/display/buffer/hdi_service/dfx/display_buffer_dfx.h b/display/buffer/hdi_service/dfx/display_buffer_dfx.h index 613604992d..f8c87deeec 100644 --- a/display/buffer/hdi_service/dfx/display_buffer_dfx.h +++ b/display/buffer/hdi_service/dfx/display_buffer_dfx.h @@ -28,7 +28,7 @@ namespace Buffer { namespace V1_0 { class DisplayBufferDfx { public: - explicit DisplayBufferDfx(std::string name); + explicit DisplayBufferDfx(const std::string name); ~DisplayBufferDfx(); void SetTimer(); void CancelTimer(); -- Gitee From e2f3ea859c1439eea60bb71b4b1a6043f32b29e6 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 14 Aug 2024 19:36:42 +0800 Subject: [PATCH 0194/1485] thread name change Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index 29b3f9884c..a948fc666d 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -711,6 +711,7 @@ static int32_t WifiMsgRegisterEventListener(void) g_wifiHalInfo.status = THREAD_STOP; return RET_CODE_FAILURE; } + pthread_setname_np(g_wifiHalInfo.thread, "EventThread"); // waiting for thread start running while (g_wifiHalInfo.status != THREAD_RUN) { -- Gitee From 7a3819f048243b93a59fc00f7edc82fdc93e3240 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 22:19:19 +0800 Subject: [PATCH 0195/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/BUILD.gn | 1 + sensor/test/unittest/dump/BUILD.gn | 56 +++++++++++++++ .../unittest/hdi/hdf_sensor_dump_test.cpp | 72 +++++++++++++++++++ 3 files changed, 129 insertions(+) create mode 100644 sensor/test/unittest/dump/BUILD.gn create mode 100644 sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp diff --git a/sensor/test/BUILD.gn b/sensor/test/BUILD.gn index 62b21ca6b1..adf1e0154b 100644 --- a/sensor/test/BUILD.gn +++ b/sensor/test/BUILD.gn @@ -37,6 +37,7 @@ if (defined(ohos_lite)) { "benchmarktest:hdf_sensor_benchmark_test", "fuzztest:hdf_sensor_fuzztest", "unittest/hdi:hdi_unittest_sensor", + "unittest/dump:dump_unittest_sensor", ] } } diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn new file mode 100644 index 0000000000..0d07bd127b --- /dev/null +++ b/sensor/test/unittest/dump/BUILD.gn @@ -0,0 +1,56 @@ +# Copyright (c) 2021-2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../sensor.gni") + +module_output_path = "drivers_peripheral_sensor/sensor" + +ohos_unittest("hdi_unittest_sensor") { + module_out_path = module_output_path + + include_dirs = [ + "../../../interfaces/include", + "../../common/include", + "../../../utils/include", + ] + + sources = [ + "../../common/src/sensor_callback_impl.cpp", + "hdf_sensor_hdi_test.cpp", + ] + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + + if (is_standard_system) { + external_deps = [ + "drivers_interface_sensor:libsensor_proxy_2.0", + "hdf_core:libhdf_utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + if (c_utils_enable) { + external_deps += [ "c_utils:utils" ] + } + } else { + external_deps = [ "hilog:libhilog" ] + } + external_deps += [ "ipc:ipc_single" ] +} diff --git a/sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp b/sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp new file mode 100644 index 0000000000..7609438a26 --- /dev/null +++ b/sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include "hdf_base.h" +#include "osal_time.h" +#include "v2_0/isensor_interface.h" +#include "sensor_type.h" +#include "sensor_callback_impl.h" +#include "sensor_uhdf_log.h" +#include "sensor_hdi_dump.h" + +using namespace OHOS::HDI::Sensor::V2_0; +using namespace testing::ext; + +namespace { + +} + +class HdfSensorDumpTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfSensorDumpTest::SetUpTestCase() +{ +} + +void HdfSensorDumpTest::TearDownTestCase() +{ +} + +void HdfSensorDumpTest::SetUp() +{ +} + +void HdfSensorDumpTest::TearDown() +{ +} + +/** + * @tc.name: SensorDumpHelpTest + * @tc.desc: Get a client and check whether the client is empty. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) +{ + struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); + struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); + HdfsbufWriteString(data, "-h"); + GetSensorDump(data, reply) +} \ No newline at end of file -- Gitee From 0551cab6baa2d2dc54a95adfa5fe41dbcf2ee475 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 22:24:55 +0800 Subject: [PATCH 0196/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/{hdi => dump}/hdf_sensor_dump_test.cpp | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sensor/test/unittest/{hdi => dump}/hdf_sensor_dump_test.cpp (100%) diff --git a/sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp similarity index 100% rename from sensor/test/unittest/hdi/hdf_sensor_dump_test.cpp rename to sensor/test/unittest/dump/hdf_sensor_dump_test.cpp -- Gitee From e5adce32fd8014e78e25744e7fdb4da5181f98e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 22:28:31 +0800 Subject: [PATCH 0197/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index 0d07bd127b..b210906f07 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -17,11 +17,12 @@ import("../../../sensor.gni") module_output_path = "drivers_peripheral_sensor/sensor" -ohos_unittest("hdi_unittest_sensor") { +ohos_unittest("dump_unittest_sensor") { module_out_path = module_output_path include_dirs = [ "../../../interfaces/include", + "../../../interfaces/v1_0", "../../common/include", "../../../utils/include", ] @@ -40,10 +41,13 @@ ohos_unittest("hdi_unittest_sensor") { ] if (is_standard_system) { + deps = [ "../../../hdi_service:libsensor_interface_service_2.0" ] external_deps = [ "drivers_interface_sensor:libsensor_proxy_2.0", + "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", + "hitrace:hitrace_meter", "ipc:ipc_single", ] if (c_utils_enable) { -- Gitee From 22f4ad62dcb11495ced3a886c1760fae916f0455 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Wed, 14 Aug 2024 22:33:14 +0800 Subject: [PATCH 0198/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index b210906f07..5cff676454 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -22,14 +22,14 @@ ohos_unittest("dump_unittest_sensor") { include_dirs = [ "../../../interfaces/include", + "../../../hdi_service", "../../../interfaces/v1_0", "../../common/include", "../../../utils/include", ] sources = [ - "../../common/src/sensor_callback_impl.cpp", - "hdf_sensor_hdi_test.cpp", + "hdf_sensor_dump_test.cpp", ] cflags = [ "-Wall", -- Gitee From f173392ce9c36553ccff050c1158db8e5def524f Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 15 Aug 2024 01:29:12 +0000 Subject: [PATCH 0199/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index a62a6a1391..7254ab419b 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -104,7 +104,7 @@ WifiError WifiVendorHal::Start() void WifiVendorHal::RunEventLoop() { - pthread_setname_np(pthread_self(), "RunEventLoop"); + pthread_setname_np(pthread_self(), "wlan_chip_event"); HDF_LOGD("Starting vendor HAL event loop"); globalFuncTable_.startHalLoop(globalHandle_); const auto lock = AcquireGlobalLock(); -- Gitee From 665a6878903b45fb34c7a2bd3d112f1b82ecbea9 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 15 Aug 2024 01:32:30 +0000 Subject: [PATCH 0200/1485] update wlan/client/src/netlink/netlink_cmd_adapter.c. Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index a948fc666d..9c4e6b87b7 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -711,7 +711,7 @@ static int32_t WifiMsgRegisterEventListener(void) g_wifiHalInfo.status = THREAD_STOP; return RET_CODE_FAILURE; } - pthread_setname_np(g_wifiHalInfo.thread, "EventThread"); + pthread_setname_np(g_wifiHalInfo.thread, "wlan_event"); // waiting for thread start running while (g_wifiHalInfo.status != THREAD_RUN) { -- Gitee From 13a7c7604913684e881b790e9f303ba797dd3b78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 09:54:28 +0800 Subject: [PATCH 0201/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 7609438a26..d7d65475b3 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -67,6 +67,6 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) { struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); - HdfsbufWriteString(data, "-h"); + HdfSbufWriteString(data, "-h"); GetSensorDump(data, reply) } \ No newline at end of file -- Gitee From 11881bb9d044de031298b446d81ad931fbbcdbde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 15 Aug 2024 01:58:57 +0000 Subject: [PATCH 0202/1485] update display/buffer/hdi_service/dfx/display_buffer_dfx.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- display/buffer/hdi_service/dfx/display_buffer_dfx.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp index 4436f32799..53be978832 100644 --- a/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp +++ b/display/buffer/hdi_service/dfx/display_buffer_dfx.cpp @@ -25,7 +25,7 @@ namespace HDI { namespace Display { namespace Buffer { namespace V1_0 { -DisplayBufferDfx::DisplayBufferDfx(const std::string name) +DisplayBufferDfx::DisplayBufferDfx(const std::string& name) : dfxName_(name), timeId_(0), flag_(false), -- Gitee From 6f62c547aaa71ebea5a3bb45a857c41908833019 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 15 Aug 2024 01:59:11 +0000 Subject: [PATCH 0203/1485] update display/buffer/hdi_service/dfx/display_buffer_dfx.h. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- display/buffer/hdi_service/dfx/display_buffer_dfx.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/display/buffer/hdi_service/dfx/display_buffer_dfx.h b/display/buffer/hdi_service/dfx/display_buffer_dfx.h index f8c87deeec..1a1e705935 100644 --- a/display/buffer/hdi_service/dfx/display_buffer_dfx.h +++ b/display/buffer/hdi_service/dfx/display_buffer_dfx.h @@ -28,7 +28,7 @@ namespace Buffer { namespace V1_0 { class DisplayBufferDfx { public: - explicit DisplayBufferDfx(const std::string name); + explicit DisplayBufferDfx(const std::string& name); ~DisplayBufferDfx(); void SetTimer(); void CancelTimer(); -- Gitee From 7279a54ae41f5bdb3dd74d8b4ceeb6a26f7d207f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 14:17:33 +0800 Subject: [PATCH 0204/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index d7d65475b3..833b242f02 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -65,8 +65,13 @@ void HdfSensorDumpTest::TearDown() */ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) { + SENSOR_TRACE; struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); + HdfSbufWriteUint32(data, 1u); HdfSbufWriteString(data, "-h"); - GetSensorDump(data, reply) + GetSensorDump(data, reply); + const char* value = HdfSbufReadString(reply); + ASSERT_NE(value, nullptr); + printf("-h value is %s", value); } \ No newline at end of file -- Gitee From f354234cd2fa423c81bf11e459ae482c88a4d98b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 14:43:50 +0800 Subject: [PATCH 0205/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 94 ++++++++++++++++++- 1 file changed, 93 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 833b242f02..528a1a1184 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -30,7 +30,12 @@ using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; namespace { - + sptr g_sensorInterface = nullptr; + sptr g_traditionalCallback = new SensorCallbackImpl(); + std::vector g_info; + constexpr int64_t g_samplingInterval = 10000000; + constexpr int64_t g_reportInterval = 1; + constexpr int32_t g_waitTime = 2; } class HdfSensorDumpTest : public testing::Test { @@ -43,6 +48,7 @@ public: void HdfSensorDumpTest::SetUpTestCase() { + g_sensorInterface = ISensorInterface::Get(); } void HdfSensorDumpTest::TearDownTestCase() @@ -74,4 +80,90 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) const char* value = HdfSbufReadString(reply); ASSERT_NE(value, nullptr); printf("-h value is %s", value); +} + +/** + * @tc.name: SensorShowClientTest + * @tc.desc: Get a client and check whether the client is empty. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) +{ + SENSOR_TRACE; + ASSERT_NE(g_sensorInterface, nullptr); + int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info); + + int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); + + struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); + struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); + HdfSbufWriteUint32(data, 1u); + HdfSbufWriteString(data, "-c"); + GetSensorDump(data, reply); + const char* value = HdfSbufReadString(reply); + ASSERT_NE(value, nullptr); + printf("-h value is %s", value); + + ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); +} + +/** + * @tc.name: SensorShowDataTest + * @tc.desc: Get a client and check whether the client is empty. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) +{ + SENSOR_TRACE; + int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); + + for (auto it : g_info) { + ret = g_sensorInterface->SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); + EXPECT_EQ(SENSOR_SUCCESS, ret); + ret = g_sensorInterface->Enable(it.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } + + OsalSleep(g_waitTime); + + for (auto it : g_info) { + ret = g_sensorInterface->Disable(it.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } + + struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); + struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); + HdfSbufWriteUint32(data, 1u); + HdfSbufWriteString(data, "-d"); + GetSensorDump(data, reply); + const char* value = HdfSbufReadString(reply); + ASSERT_NE(value, nullptr); + printf("-h value is %s", value); + + ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + EXPECT_EQ(SENSOR_SUCCESS, ret); +} + +/** + * @tc.name: SensorShowListTest + * @tc.desc: Get a client and check whether the client is empty. + * @tc.type: FUNC + * @tc.require: #I4L3LF + */ +HWTEST_F(HdfSensorDumpTest, SensorShowListTest, TestSize.Level1) +{ + SENSOR_TRACE; + struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); + struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); + HdfSbufWriteUint32(data, 1u); + HdfSbufWriteString(data, "-l"); + GetSensorDump(data, reply); + const char* value = HdfSbufReadString(reply); + ASSERT_NE(value, nullptr); + printf("-h value is %s", value); } \ No newline at end of file -- Gitee From 1cb25e1209421c2a3a0336e9b9a8ee9f0bf3714f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 14:46:35 +0800 Subject: [PATCH 0206/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 528a1a1184..11b3f716f3 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -93,8 +93,9 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) SENSOR_TRACE; ASSERT_NE(g_sensorInterface, nullptr); int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info); + EXPECT_EQ(SENSOR_SUCCESS, ret); - int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); -- Gitee From 0d8e401613adc554b9d4c6f0e869c25c8257c0e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 14:51:10 +0800 Subject: [PATCH 0207/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index 5cff676454..bb80b477bd 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -29,6 +29,7 @@ ohos_unittest("dump_unittest_sensor") { ] sources = [ + "../../common/src/sensor_callback_impl.cpp", "hdf_sensor_dump_test.cpp", ] cflags = [ -- Gitee From 5773c3ccc555a2bdd16957e67d2ecaafaefcbebe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 15:38:53 +0800 Subject: [PATCH 0208/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 11b3f716f3..c4a2c18c75 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -31,6 +31,7 @@ using namespace testing::ext; namespace { sptr g_sensorInterface = nullptr; + sptr g_sensorIfService = nullptr; sptr g_traditionalCallback = new SensorCallbackImpl(); std::vector g_info; constexpr int64_t g_samplingInterval = 10000000; @@ -49,6 +50,7 @@ public: void HdfSensorDumpTest::SetUpTestCase() { g_sensorInterface = ISensorInterface::Get(); + g_sensorIfService = SensorInterfaceImplGetInstance(); } void HdfSensorDumpTest::TearDownTestCase() @@ -91,11 +93,11 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) { SENSOR_TRACE; - ASSERT_NE(g_sensorInterface, nullptr); - int32_t ret = g_sensorInterface->GetAllSensorInfo(g_info); + ASSERT_NE(g_sensorIfService, nullptr); + int32_t ret = g_sensorIfService->GetAllSensorInfo(g_info); EXPECT_EQ(SENSOR_SUCCESS, ret); - ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + ret = g_sensorIfService->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); @@ -107,7 +109,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) ASSERT_NE(value, nullptr); printf("-h value is %s", value); - ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + ret = g_sensorIfService->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); } @@ -120,20 +122,20 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) { SENSOR_TRACE; - int32_t ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + int32_t ret = g_sensorIfService->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); for (auto it : g_info) { - ret = g_sensorInterface->SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); + ret = g_sensorIfService->SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); EXPECT_EQ(SENSOR_SUCCESS, ret); - ret = g_sensorInterface->Enable(it.sensorId); + ret = g_sensorIfService->Enable(it.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); } OsalSleep(g_waitTime); for (auto it : g_info) { - ret = g_sensorInterface->Disable(it.sensorId); + ret = g_sensorIfService->Disable(it.sensorId); EXPECT_EQ(SENSOR_SUCCESS, ret); } @@ -146,7 +148,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) ASSERT_NE(value, nullptr); printf("-h value is %s", value); - ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + ret = g_sensorIfService->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); } -- Gitee From b97d6aa8f167a7e51044bfe3f37db32aed683806 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 16:04:44 +0800 Subject: [PATCH 0209/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index c4a2c18c75..cabb4fa691 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -30,7 +30,6 @@ using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; namespace { - sptr g_sensorInterface = nullptr; sptr g_sensorIfService = nullptr; sptr g_traditionalCallback = new SensorCallbackImpl(); std::vector g_info; @@ -49,8 +48,12 @@ public: void HdfSensorDumpTest::SetUpTestCase() { - g_sensorInterface = ISensorInterface::Get(); - g_sensorIfService = SensorInterfaceImplGetInstance(); + g_sensorIfService = new SensorIfService(); + int32_t ret = g_sensorIfService->Init(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret); + delete impl; + } } void HdfSensorDumpTest::TearDownTestCase() -- Gitee From 3a7c7f781b84df67b322de0e70c4a26bf4e04e4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 16:05:08 +0800 Subject: [PATCH 0210/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index bb80b477bd..0d8273358b 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -46,6 +46,7 @@ ohos_unittest("dump_unittest_sensor") { external_deps = [ "drivers_interface_sensor:libsensor_proxy_2.0", "hdf_core:libhdf_host", + "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hilog:libhilog", "hitrace:hitrace_meter", -- Gitee From d1f83a9111fd0f206bde0b30c7d0a0c009e47671 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 18:05:59 +0800 Subject: [PATCH 0211/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 1 - .../unittest/dump/hdf_sensor_dump_test.cpp | 87 +++++++++++++------ 2 files changed, 59 insertions(+), 29 deletions(-) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index 0d8273358b..bb80b477bd 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -46,7 +46,6 @@ ohos_unittest("dump_unittest_sensor") { external_deps = [ "drivers_interface_sensor:libsensor_proxy_2.0", "hdf_core:libhdf_host", - "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hilog:libhilog", "hitrace:hitrace_meter", diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index cabb4fa691..b54486a54e 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -25,13 +25,12 @@ #include "sensor_callback_impl.h" #include "sensor_uhdf_log.h" #include "sensor_hdi_dump.h" +#include "sensor_clients_manager.h" using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; namespace { - sptr g_sensorIfService = nullptr; - sptr g_traditionalCallback = new SensorCallbackImpl(); std::vector g_info; constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; @@ -44,16 +43,54 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); + void GetAllSensorInfo(std::vector &info) + { + struct HdfSensorInformation sensorInfo = {}; + sensorInfo.sensorName = "test_accelerometer"; + sensorInfo.vendorName = "test_accelerometer"; + sensorInfo.firmwareVersion = "test_accelerometer"; + sensorInfo.hardwareVersion = "test_accelerometer"; + sensorInfo.sensorTypeId = 1; + sensorInfo.sensorId = 1; + sensorInfo.maxRange = 999; + sensorInfo.accuracy = 100; + sensorInfo.power = 1; + sensorInfo.minDelay = 10; + sensorInfo.maxDelay = 1000000000; + sensorInfo.fifoMaxEventCount = 10; + info.push_back(std::move(sensorInfo)); + SensorClientsManager::GetInstance()->CopySensorInfo(info, COPY_SENSORINFO); + } + void Register(int32_t groupId, const sptr &callbackObj) + { + SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); + } + void UnRegister(int32_t groupId, const sptr &callbackObj) + { + SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, serviceId, callbackObj); + } + void SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) + { + SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, serviceId, samplingInterval, reportInterval); + SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, saSamplingInterval, saReportInterval); + SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, saSamplingInterval, saReportInterval); + } + void Enable(int32_t sensorId) + { + SensorClientsManager::GetInstance()->OpenSensor(sensorId, serviceId); + } + void Disable(int32_t sensorId) + { + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR) + } + void OnDataEvent(const V2_0::HdfSensorEvents& event) + { + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR) + } }; void HdfSensorDumpTest::SetUpTestCase() { - g_sensorIfService = new SensorIfService(); - int32_t ret = g_sensorIfService->Init(); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: service init failed, error code is %{public}d", __func__, ret); - delete impl; - } } void HdfSensorDumpTest::TearDownTestCase() @@ -96,12 +133,14 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) { SENSOR_TRACE; - ASSERT_NE(g_sensorIfService, nullptr); - int32_t ret = g_sensorIfService->GetAllSensorInfo(g_info); - EXPECT_EQ(SENSOR_SUCCESS, ret); - - ret = g_sensorIfService->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); - EXPECT_EQ(SENSOR_SUCCESS, ret); + GetAllSensorInfo(g_info); + Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + for (auto it : g_info) { + SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); + EXPECT_EQ(SENSOR_SUCCESS, ret); + Enable(it.sensorId); + EXPECT_EQ(SENSOR_SUCCESS, ret); + } struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); @@ -112,7 +151,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) ASSERT_NE(value, nullptr); printf("-h value is %s", value); - ret = g_sensorIfService->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); } @@ -125,21 +164,13 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) { SENSOR_TRACE; - int32_t ret = g_sensorIfService->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); + V2_0::HdfSensorEvents event; for (auto it : g_info) { - ret = g_sensorIfService->SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); - EXPECT_EQ(SENSOR_SUCCESS, ret); - ret = g_sensorIfService->Enable(it.sensorId); - EXPECT_EQ(SENSOR_SUCCESS, ret); - } - - OsalSleep(g_waitTime); - - for (auto it : g_info) { - ret = g_sensorIfService->Disable(it.sensorId); - EXPECT_EQ(SENSOR_SUCCESS, ret); + event.sensorId = it.sensorId; + OnDataEvent(event) } struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); @@ -151,7 +182,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) ASSERT_NE(value, nullptr); printf("-h value is %s", value); - ret = g_sensorIfService->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); + Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); EXPECT_EQ(SENSOR_SUCCESS, ret); } -- Gitee From 034d7d6c0a8f2c9e9bd3ea99e92059c81c660d48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 18:07:21 +0800 Subject: [PATCH 0212/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index b54486a54e..01c9525f01 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -81,11 +81,11 @@ public: } void Disable(int32_t sensorId) { - SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR) + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR); } void OnDataEvent(const V2_0::HdfSensorEvents& event) { - SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR) + SensorClientsManager::GetInstance()->CopyEventData(event); } }; -- Gitee From 747a89f28cb662a17a5ac3b3e3180846057227f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 19:13:02 +0800 Subject: [PATCH 0213/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 01c9525f01..4f4901e3f0 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -27,6 +27,7 @@ #include "sensor_hdi_dump.h" #include "sensor_clients_manager.h" +using namespace OHOS::HDI::Sensor; using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; @@ -35,6 +36,7 @@ namespace { constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; constexpr int32_t g_waitTime = 2; + constexpr int32_t g_serviceId = getpid(); } class HdfSensorDumpTest : public testing::Test { @@ -59,7 +61,7 @@ public: sensorInfo.maxDelay = 1000000000; sensorInfo.fifoMaxEventCount = 10; info.push_back(std::move(sensorInfo)); - SensorClientsManager::GetInstance()->CopySensorInfo(info, COPY_SENSORINFO); + SensorClientsManager::GetInstance()->CopySensorInfo(info, 1); } void Register(int32_t groupId, const sptr &callbackObj) { @@ -67,21 +69,21 @@ public: } void UnRegister(int32_t groupId, const sptr &callbackObj) { - SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, serviceId, callbackObj); + SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, g_serviceId, callbackObj); } void SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) { - SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, serviceId, samplingInterval, reportInterval); + SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, g_serviceId, samplingInterval, reportInterval); SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, saSamplingInterval, saReportInterval); SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, saSamplingInterval, saReportInterval); } void Enable(int32_t sensorId) { - SensorClientsManager::GetInstance()->OpenSensor(sensorId, serviceId); + SensorClientsManager::GetInstance()->OpenSensor(sensorId, g_serviceId); } void Disable(int32_t sensorId) { - SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, serviceId, DISABLE_SENSOR); + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, DISABLE_SENSOR); } void OnDataEvent(const V2_0::HdfSensorEvents& event) { -- Gitee From fecdbd77a26ec54483d0addc0324c00a1cf856b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Thu, 15 Aug 2024 11:17:36 +0000 Subject: [PATCH 0214/1485] update audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- .../common/adapter/src/audio_idlhdi_adapter_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp index 8e3ec2b3c2..d54c8cad48 100644 --- a/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp +++ b/audio/test/systemtest/hdi_service/common/adapter/src/audio_idlhdi_adapter_test.cpp @@ -810,9 +810,10 @@ HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_004, TestSize.Level1) attrs.format = AUDIO_FORMAT_TYPE_AAC_MAIN; ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_); ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS); + InitAttrs(attrs); attrs.type = AUDIO_IN_COMMUNICATION; ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_); - EXPECT_EQ(HDF_FAILURE, ret); + EXPECT_EQ(HDF_SUCCESS, ret); manager->UnloadAdapter(manager, ADAPTER_NAME.c_str()); IAudioAdapterRelease(adapter, IS_STUB); -- Gitee From 9cf8067c536437daa5a4735c959bed2636662efb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 19:23:03 +0800 Subject: [PATCH 0215/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 4f4901e3f0..f82e80360b 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -32,11 +32,12 @@ using namespace OHOS::HDI::Sensor::V2_0; using namespace testing::ext; namespace { + sptr g_traditionalCallback = new SensorCallbackImpl(); std::vector g_info; constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; constexpr int32_t g_waitTime = 2; - constexpr int32_t g_serviceId = getpid(); + constexpr int32_t g_serviceId = 1314; } class HdfSensorDumpTest : public testing::Test { @@ -67,15 +68,15 @@ public: { SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); } - void UnRegister(int32_t groupId, const sptr &callbackObj) + void Unregister(int32_t groupId, const sptr &callbackObj) { SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, g_serviceId, callbackObj); } void SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) { SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, g_serviceId, samplingInterval, reportInterval); - SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, saSamplingInterval, saReportInterval); - SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, saSamplingInterval, saReportInterval); + SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, samplingInterval, reportInterval); + SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, samplingInterval, reportInterval); } void Enable(int32_t sensorId) { @@ -83,7 +84,7 @@ public: } void Disable(int32_t sensorId) { - SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, DISABLE_SENSOR); + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, 0); } void OnDataEvent(const V2_0::HdfSensorEvents& event) { @@ -139,9 +140,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); for (auto it : g_info) { SetBatch(it.sensorId, g_reportInterval, g_samplingInterval); - EXPECT_EQ(SENSOR_SUCCESS, ret); Enable(it.sensorId); - EXPECT_EQ(SENSOR_SUCCESS, ret); } struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); @@ -154,7 +153,6 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) printf("-h value is %s", value); Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); - EXPECT_EQ(SENSOR_SUCCESS, ret); } /** @@ -167,12 +165,11 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) { SENSOR_TRACE; Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); - EXPECT_EQ(SENSOR_SUCCESS, ret); V2_0::HdfSensorEvents event; for (auto it : g_info) { event.sensorId = it.sensorId; - OnDataEvent(event) + OnDataEvent(event); } struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); @@ -185,7 +182,6 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) printf("-h value is %s", value); Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); - EXPECT_EQ(SENSOR_SUCCESS, ret); } /** -- Gitee From cfd52610e60e71d16ed79583c307e855a596d42b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 19:24:20 +0800 Subject: [PATCH 0216/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index f82e80360b..729df47145 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -36,7 +36,6 @@ namespace { std::vector g_info; constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; - constexpr int32_t g_waitTime = 2; constexpr int32_t g_serviceId = 1314; } -- Gitee From 348ee0ae94f8c144ecc9af6c67a8b09e90b9f767 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 19:38:09 +0800 Subject: [PATCH 0217/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 729df47145..4f6528e426 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -89,6 +89,16 @@ public: { SensorClientsManager::GetInstance()->CopyEventData(event); } + void PrintDumpResult(struct HdfSBuf* reply) + { + while (true) { + const char* value = HdfSbufReadString(reply); + if (value == nullptr) { + return; + } + printf("%s", value); + } + } }; void HdfSensorDumpTest::SetUpTestCase() @@ -121,9 +131,7 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) HdfSbufWriteUint32(data, 1u); HdfSbufWriteString(data, "-h"); GetSensorDump(data, reply); - const char* value = HdfSbufReadString(reply); - ASSERT_NE(value, nullptr); - printf("-h value is %s", value); + PrintDumpResult(reply); } /** @@ -147,9 +155,8 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) HdfSbufWriteUint32(data, 1u); HdfSbufWriteString(data, "-c"); GetSensorDump(data, reply); - const char* value = HdfSbufReadString(reply); - ASSERT_NE(value, nullptr); - printf("-h value is %s", value); + + PrintDumpResult(reply); Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); } @@ -176,9 +183,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) HdfSbufWriteUint32(data, 1u); HdfSbufWriteString(data, "-d"); GetSensorDump(data, reply); - const char* value = HdfSbufReadString(reply); - ASSERT_NE(value, nullptr); - printf("-h value is %s", value); + PrintDumpResult(reply); Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback); } @@ -197,7 +202,5 @@ HWTEST_F(HdfSensorDumpTest, SensorShowListTest, TestSize.Level1) HdfSbufWriteUint32(data, 1u); HdfSbufWriteString(data, "-l"); GetSensorDump(data, reply); - const char* value = HdfSbufReadString(reply); - ASSERT_NE(value, nullptr); - printf("-h value is %s", value); + PrintDumpResult(reply); } \ No newline at end of file -- Gitee From 4897be2fd3b9979efa044f44699d3c866371f91b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 19:55:13 +0800 Subject: [PATCH 0218/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 4f6528e426..464360fd0e 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -175,6 +175,12 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) V2_0::HdfSensorEvents event; for (auto it : g_info) { event.sensorId = it.sensorId; + event.version = 1; + event.timestamp = 100000000; + event.option = 1; + event.mode = 1; + event.data = [1, 2, 3]; + event.dataLen = 3; OnDataEvent(event); } -- Gitee From 3ea158342c73b4e73271344b2a092821a9fabed2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 20:20:21 +0800 Subject: [PATCH 0219/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 464360fd0e..500aab9cb0 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -179,7 +179,9 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) event.timestamp = 100000000; event.option = 1; event.mode = 1; - event.data = [1, 2, 3]; + event.data.push_back(1); + event.data.push_back(2); + event.data.push_back(3); event.dataLen = 3; OnDataEvent(event); } -- Gitee From 40bbf25966a6e10b89480bb40f5ebace7642e68d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:05:13 +0800 Subject: [PATCH 0220/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 500aab9cb0..b79a3b48f9 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -182,7 +182,8 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) event.data.push_back(1); event.data.push_back(2); event.data.push_back(3); - event.dataLen = 3; + event.data.push_back(4); + event.dataLen = 4; OnDataEvent(event); } -- Gitee From 7043666d27a3cf8e90e0015d312b8508371c36f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:10:17 +0800 Subject: [PATCH 0221/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 126 ++++++++++-------- 1 file changed, 72 insertions(+), 54 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index b79a3b48f9..a7fa65baef 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -45,60 +45,14 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - void GetAllSensorInfo(std::vector &info) - { - struct HdfSensorInformation sensorInfo = {}; - sensorInfo.sensorName = "test_accelerometer"; - sensorInfo.vendorName = "test_accelerometer"; - sensorInfo.firmwareVersion = "test_accelerometer"; - sensorInfo.hardwareVersion = "test_accelerometer"; - sensorInfo.sensorTypeId = 1; - sensorInfo.sensorId = 1; - sensorInfo.maxRange = 999; - sensorInfo.accuracy = 100; - sensorInfo.power = 1; - sensorInfo.minDelay = 10; - sensorInfo.maxDelay = 1000000000; - sensorInfo.fifoMaxEventCount = 10; - info.push_back(std::move(sensorInfo)); - SensorClientsManager::GetInstance()->CopySensorInfo(info, 1); - } - void Register(int32_t groupId, const sptr &callbackObj) - { - SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); - } - void Unregister(int32_t groupId, const sptr &callbackObj) - { - SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, g_serviceId, callbackObj); - } - void SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) - { - SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, g_serviceId, samplingInterval, reportInterval); - SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, samplingInterval, reportInterval); - SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, samplingInterval, reportInterval); - } - void Enable(int32_t sensorId) - { - SensorClientsManager::GetInstance()->OpenSensor(sensorId, g_serviceId); - } - void Disable(int32_t sensorId) - { - SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, 0); - } - void OnDataEvent(const V2_0::HdfSensorEvents& event) - { - SensorClientsManager::GetInstance()->CopyEventData(event); - } - void PrintDumpResult(struct HdfSBuf* reply) - { - while (true) { - const char* value = HdfSbufReadString(reply); - if (value == nullptr) { - return; - } - printf("%s", value); - } - } + void GetAllSensorInfo(std::vector &info); + void Register(int32_t groupId, const sptr &callbackObj); + void Unregister(int32_t groupId, const sptr &callbackObj); + void SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval); + void Enable(int32_t sensorId); + void Disable(int32_t sensorId); + void OnDataEvent(const V2_0::HdfSensorEvents& event); + void PrintDumpResult(struct HdfSBuf* reply); }; void HdfSensorDumpTest::SetUpTestCase() @@ -117,6 +71,70 @@ void HdfSensorDumpTest::TearDown() { } +void HdfSensorDumpTest::GetAllSensorInfo(std::vector &info) +{ + struct HdfSensorInformation sensorInfo = {}; + for (int32_t sensorId = 1; sensorId < 10; sensorId++) { + sensorInfo.sensorName = "test_accelerometer" + std::to_string(sensorId); + sensorInfo.vendorName = "test_accelerometer" + std::to_string(sensorId); + sensorInfo.firmwareVersion = "test_accelerometer" + std::to_string(sensorId); + sensorInfo.hardwareVersion = "test_accelerometer" + std::to_string(sensorId); + sensorInfo.sensorTypeId = sensorId; + sensorInfo.sensorId = sensorId; + sensorInfo.maxRange = 1000 + sensorId; + sensorInfo.accuracy = 100 + sensorId; + sensorInfo.power = 1 + sensorId; + sensorInfo.minDelay = 10 + sensorId; + sensorInfo.maxDelay = 1000000000 + sensorId; + sensorInfo.fifoMaxEventCount = 10 + sensorId; + info.push_back(std::move(sensorInfo)); + SensorClientsManager::GetInstance()->CopySensorInfo(info, 1); + } +} + +void HdfSensorDumpTest::Register(int32_t groupId, const sptr &callbackObj) +{ + SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); +} + +void HdfSensorDumpTest::Unregister(int32_t groupId, const sptr &callbackObj) +{ + SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, g_serviceId, callbackObj); +} + +void HdfSensorDumpTest::SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) +{ + SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, g_serviceId, samplingInterval, reportInterval); + SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, samplingInterval, reportInterval); + SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, samplingInterval, reportInterval); +} + +void HdfSensorDumpTest::Enable(int32_t sensorId) +{ + SensorClientsManager::GetInstance()->OpenSensor(sensorId, g_serviceId); +} + +void HdfSensorDumpTest::Disable(int32_t sensorId) +{ + SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, 0); +} + +void HdfSensorDumpTest::OnDataEvent(const V2_0::HdfSensorEvents& event) +{ + SensorClientsManager::GetInstance()->CopyEventData(event); +} + +void HdfSensorDumpTest::PrintDumpResult(struct HdfSBuf* reply) +{ + while (true) { + const char* value = HdfSbufReadString(reply); + if (value == nullptr) { + return; + } + printf("%s", value); + } +} + /** * @tc.name: SensorDumpHelpTest * @tc.desc: Get a client and check whether the client is empty. -- Gitee From 203f935e9d2b35e4e28ddf3f5fd0d64453b9093f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:21:13 +0800 Subject: [PATCH 0222/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/BUILD.gn b/sensor/test/unittest/dump/BUILD.gn index bb80b477bd..b9905538a6 100644 --- a/sensor/test/unittest/dump/BUILD.gn +++ b/sensor/test/unittest/dump/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2023 Huawei Device Co., Ltd. +# Copyright (c) 2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at -- Gitee From c21363f99951d7b5e69222f9c1a6f6775304121c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:31:42 +0800 Subject: [PATCH 0223/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- .../unittest/dump/hdf_sensor_dump_test.cpp | 56 ++++++++++--------- 1 file changed, 29 insertions(+), 27 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index a7fa65baef..e0ffeeb8a4 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -37,6 +37,16 @@ namespace { constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; constexpr int32_t g_serviceId = 1314; + constexpr int32_t g_sensorIdStart = 1; + constexpr int32_t g_sensorIdEnd = 10; + constexpr int32_t g_maxRange = 1000; + constexpr int32_t g_accuracy = 100; + constexpr int32_t g_power = 1; + constexpr int32_t g_minDelay = 10; + constexpr int32_t g_maxDelay = 1000000000; + constexpr int32_t g_copyFlag = 1; + constexpr uint32_t g_initDataNum = 1u; + constexpr std::string g_sensorName = "test_accelerometer"; } class HdfSensorDumpTest : public testing::Test { @@ -53,6 +63,7 @@ public: void Disable(int32_t sensorId); void OnDataEvent(const V2_0::HdfSensorEvents& event); void PrintDumpResult(struct HdfSBuf* reply); + V2_0::HdfSensorEvents g_event = {1, 1, 100000000, 1, 1, {1, 2, 3, 4}, 4}; }; void HdfSensorDumpTest::SetUpTestCase() @@ -74,21 +85,21 @@ void HdfSensorDumpTest::TearDown() void HdfSensorDumpTest::GetAllSensorInfo(std::vector &info) { struct HdfSensorInformation sensorInfo = {}; - for (int32_t sensorId = 1; sensorId < 10; sensorId++) { - sensorInfo.sensorName = "test_accelerometer" + std::to_string(sensorId); - sensorInfo.vendorName = "test_accelerometer" + std::to_string(sensorId); - sensorInfo.firmwareVersion = "test_accelerometer" + std::to_string(sensorId); - sensorInfo.hardwareVersion = "test_accelerometer" + std::to_string(sensorId); + for (int32_t sensorId = g_sensorIdStart; sensorId <= g_sensorIdEnd; sensorId++) { + sensorInfo.sensorName = g_sensorName + std::to_string(sensorId); + sensorInfo.vendorName = g_sensorName + std::to_string(sensorId); + sensorInfo.firmwareVersion = g_sensorName + std::to_string(sensorId); + sensorInfo.hardwareVersion = g_sensorName + std::to_string(sensorId); sensorInfo.sensorTypeId = sensorId; sensorInfo.sensorId = sensorId; - sensorInfo.maxRange = 1000 + sensorId; - sensorInfo.accuracy = 100 + sensorId; - sensorInfo.power = 1 + sensorId; - sensorInfo.minDelay = 10 + sensorId; - sensorInfo.maxDelay = 1000000000 + sensorId; - sensorInfo.fifoMaxEventCount = 10 + sensorId; + sensorInfo.maxRange = g_maxRange + sensorId; + sensorInfo.accuracy = g_accuracy + sensorId; + sensorInfo.power = g_power + sensorId; + sensorInfo.minDelay = g_minDelay + sensorId; + sensorInfo.maxDelay = g_maxDelay + sensorId; + sensorInfo.fifoMaxEventCount = g_fifoMaxEventCount + sensorId; info.push_back(std::move(sensorInfo)); - SensorClientsManager::GetInstance()->CopySensorInfo(info, 1); + SensorClientsManager::GetInstance()->CopySensorInfo(info, g_copyFlag); } } @@ -146,7 +157,7 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) SENSOR_TRACE; struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); - HdfSbufWriteUint32(data, 1u); + HdfSbufWriteUint32(data, g_initDataNum); HdfSbufWriteString(data, "-h"); GetSensorDump(data, reply); PrintDumpResult(reply); @@ -170,7 +181,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); - HdfSbufWriteUint32(data, 1u); + HdfSbufWriteUint32(data, g_initDataNum); HdfSbufWriteString(data, "-c"); GetSensorDump(data, reply); @@ -192,22 +203,13 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) V2_0::HdfSensorEvents event; for (auto it : g_info) { - event.sensorId = it.sensorId; - event.version = 1; - event.timestamp = 100000000; - event.option = 1; - event.mode = 1; - event.data.push_back(1); - event.data.push_back(2); - event.data.push_back(3); - event.data.push_back(4); - event.dataLen = 4; - OnDataEvent(event); + g_event.sensorId = it.sensorId; + OnDataEvent(g_event); } struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); - HdfSbufWriteUint32(data, 1u); + HdfSbufWriteUint32(data, g_initDataNum); HdfSbufWriteString(data, "-d"); GetSensorDump(data, reply); PrintDumpResult(reply); @@ -226,7 +228,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowListTest, TestSize.Level1) SENSOR_TRACE; struct HdfSBuf* reply = HdfSbufTypedObtain(SBUF_IPC); struct HdfSBuf* data = HdfSbufTypedObtain(SBUF_IPC); - HdfSbufWriteUint32(data, 1u); + HdfSbufWriteUint32(data, g_initDataNum); HdfSbufWriteString(data, "-l"); GetSensorDump(data, reply); PrintDumpResult(reply); -- Gitee From 83c1164cb7acef3dcea2e3df9e9b45dcbd3403a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:34:40 +0800 Subject: [PATCH 0224/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index e0ffeeb8a4..92cbf653a4 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -44,6 +44,7 @@ namespace { constexpr int32_t g_power = 1; constexpr int32_t g_minDelay = 10; constexpr int32_t g_maxDelay = 1000000000; + constexpr int32_t g_fifoMaxEventCount = 4; constexpr int32_t g_copyFlag = 1; constexpr uint32_t g_initDataNum = 1u; constexpr std::string g_sensorName = "test_accelerometer"; -- Gitee From 80279ec2e8f853258165e72007f757cf2f075737 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:35:21 +0800 Subject: [PATCH 0225/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 92cbf653a4..a03a7fce9c 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -47,7 +47,7 @@ namespace { constexpr int32_t g_fifoMaxEventCount = 4; constexpr int32_t g_copyFlag = 1; constexpr uint32_t g_initDataNum = 1u; - constexpr std::string g_sensorName = "test_accelerometer"; + constexpr std::string g_sensorName = "test_sensor"; } class HdfSensorDumpTest : public testing::Test { -- Gitee From 0d390257efba1ec73d890325415c7ec089365ec3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:36:00 +0800 Subject: [PATCH 0226/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index a03a7fce9c..31184dbec8 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -47,7 +47,7 @@ namespace { constexpr int32_t g_fifoMaxEventCount = 4; constexpr int32_t g_copyFlag = 1; constexpr uint32_t g_initDataNum = 1u; - constexpr std::string g_sensorName = "test_sensor"; + const std::string g_sensorName = "test_sensor"; } class HdfSensorDumpTest : public testing::Test { -- Gitee From 380cfda6b17d91c796ac8efb742b452de08aede1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 21:56:50 +0800 Subject: [PATCH 0227/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 31184dbec8..8031f5d2ec 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -149,7 +149,7 @@ void HdfSensorDumpTest::PrintDumpResult(struct HdfSBuf* reply) /** * @tc.name: SensorDumpHelpTest - * @tc.desc: Get a client and check whether the client is empty. + * @tc.desc: hdc shell "hidumper -s 5100 -a '-host sensor_host -h'" * @tc.type: FUNC * @tc.require: #I4L3LF */ @@ -166,7 +166,7 @@ HWTEST_F(HdfSensorDumpTest, SensorDumpHelpTest, TestSize.Level1) /** * @tc.name: SensorShowClientTest - * @tc.desc: Get a client and check whether the client is empty. + * @tc.desc: hdc shell "hidumper -s 5100 -a '-host sensor_host -c'" * @tc.type: FUNC * @tc.require: #I4L3LF */ @@ -193,7 +193,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowClientTest, TestSize.Level1) /** * @tc.name: SensorShowDataTest - * @tc.desc: Get a client and check whether the client is empty. + * @tc.desc: hdc shell "hidumper -s 5100 -a '-host sensor_host -d'" * @tc.type: FUNC * @tc.require: #I4L3LF */ @@ -220,7 +220,7 @@ HWTEST_F(HdfSensorDumpTest, SensorShowDataTest, TestSize.Level1) /** * @tc.name: SensorShowListTest - * @tc.desc: Get a client and check whether the client is empty. + * @tc.desc: hdc shell "hidumper -s 5100 -a '-host sensor_host -l'" * @tc.type: FUNC * @tc.require: #I4L3LF */ -- Gitee From 2b1933da73ea84a11df68b965685ed19cbe410cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 22:15:22 +0800 Subject: [PATCH 0228/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 8031f5d2ec..d47386eb8d 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -85,6 +85,7 @@ void HdfSensorDumpTest::TearDown() void HdfSensorDumpTest::GetAllSensorInfo(std::vector &info) { + SENSOR_TRACE; struct HdfSensorInformation sensorInfo = {}; for (int32_t sensorId = g_sensorIdStart; sensorId <= g_sensorIdEnd; sensorId++) { sensorInfo.sensorName = g_sensorName + std::to_string(sensorId); @@ -106,16 +107,19 @@ void HdfSensorDumpTest::GetAllSensorInfo(std::vector &info void HdfSensorDumpTest::Register(int32_t groupId, const sptr &callbackObj) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); } void HdfSensorDumpTest::Unregister(int32_t groupId, const sptr &callbackObj) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->ReportDataCbUnRegister(groupId, g_serviceId, callbackObj); } void HdfSensorDumpTest::SetBatch(int32_t sensorId, int64_t samplingInterval, int64_t reportInterval) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->SetClientSenSorConfig(sensorId, g_serviceId, samplingInterval, reportInterval); SensorClientsManager::GetInstance()->UpdateSensorConfig(sensorId, samplingInterval, reportInterval); SensorClientsManager::GetInstance()->UpdateClientPeriodCount(sensorId, samplingInterval, reportInterval); @@ -123,21 +127,25 @@ void HdfSensorDumpTest::SetBatch(int32_t sensorId, int64_t samplingInterval, int void HdfSensorDumpTest::Enable(int32_t sensorId) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->OpenSensor(sensorId, g_serviceId); } void HdfSensorDumpTest::Disable(int32_t sensorId) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->IsUpadateSensorState(sensorId, g_serviceId, 0); } void HdfSensorDumpTest::OnDataEvent(const V2_0::HdfSensorEvents& event) { + SENSOR_TRACE; SensorClientsManager::GetInstance()->CopyEventData(event); } void HdfSensorDumpTest::PrintDumpResult(struct HdfSBuf* reply) { + SENSOR_TRACE; while (true) { const char* value = HdfSbufReadString(reply); if (value == nullptr) { -- Gitee From 1d882abbc5c06f4f2e86d9086e972f7977aba5ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 17:14:57 +0000 Subject: [PATCH 0229/1485] update sensor/test/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/BUILD.gn b/sensor/test/BUILD.gn index adf1e0154b..d6c5a12fdb 100644 --- a/sensor/test/BUILD.gn +++ b/sensor/test/BUILD.gn @@ -36,8 +36,8 @@ if (defined(ohos_lite)) { deps += [ "benchmarktest:hdf_sensor_benchmark_test", "fuzztest:hdf_sensor_fuzztest", - "unittest/hdi:hdi_unittest_sensor", "unittest/dump:dump_unittest_sensor", + "unittest/hdi:hdi_unittest_sensor", ] } } -- Gitee From 04dbec7dfc95c0eecfd2fed828c8721cd43e16e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Thu, 15 Aug 2024 17:30:17 +0000 Subject: [PATCH 0230/1485] update sensor/test/unittest/dump/hdf_sensor_dump_test.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index d47386eb8d..5ebd698b57 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -146,11 +146,8 @@ void HdfSensorDumpTest::OnDataEvent(const V2_0::HdfSensorEvents& event) void HdfSensorDumpTest::PrintDumpResult(struct HdfSBuf* reply) { SENSOR_TRACE; - while (true) { - const char* value = HdfSbufReadString(reply); - if (value == nullptr) { - return; - } + const char* value = nullptr; + while ((value = HdfSbufReadString(reply)) != nullptr)) { printf("%s", value); } } -- Gitee From 53fc1a220be9c3c2175ae23c1e249d9814e3749a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 16 Aug 2024 09:31:46 +0800 Subject: [PATCH 0231/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 5ebd698b57..1a9b02a06c 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -147,7 +147,7 @@ void HdfSensorDumpTest::PrintDumpResult(struct HdfSBuf* reply) { SENSOR_TRACE; const char* value = nullptr; - while ((value = HdfSbufReadString(reply)) != nullptr)) { + while ((value = HdfSbufReadString(reply)) != nullptr) { printf("%s", value); } } -- Gitee From 3fdf43460f6e816b82b01c5a49a51474152dd511 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 16 Aug 2024 10:16:38 +0800 Subject: [PATCH 0232/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index 1a9b02a06c..d1bd5ed6d4 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -69,6 +69,7 @@ public: void HdfSensorDumpTest::SetUpTestCase() { + g_serviceId = getpid(); } void HdfSensorDumpTest::TearDownTestCase() @@ -108,7 +109,7 @@ void HdfSensorDumpTest::GetAllSensorInfo(std::vector &info void HdfSensorDumpTest::Register(int32_t groupId, const sptr &callbackObj) { SENSOR_TRACE; - SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, getpid(), callbackObj); + SensorClientsManager::GetInstance()->ReportDataCbRegister(groupId, g_serviceId, callbackObj); } void HdfSensorDumpTest::Unregister(int32_t groupId, const sptr &callbackObj) -- Gitee From 1241fc86b0c5981226e0f2e2107079638ff2fa7e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 16 Aug 2024 10:20:03 +0800 Subject: [PATCH 0233/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/unittest/dump/hdf_sensor_dump_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp index d1bd5ed6d4..b1804302fa 100644 --- a/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp +++ b/sensor/test/unittest/dump/hdf_sensor_dump_test.cpp @@ -36,7 +36,7 @@ namespace { std::vector g_info; constexpr int64_t g_samplingInterval = 10000000; constexpr int64_t g_reportInterval = 1; - constexpr int32_t g_serviceId = 1314; + int32_t g_serviceId = 1314; constexpr int32_t g_sensorIdStart = 1; constexpr int32_t g_sensorIdEnd = 10; constexpr int32_t g_maxRange = 1000; -- Gitee From 65b64bb41d883233d52fddc702113f151c99de79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E6=96=87=E9=BE=99?= Date: Fri, 16 Aug 2024 17:04:12 +0800 Subject: [PATCH 0234/1485] bugfix:delete disablegnss MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 李文龙 --- location/gnss/hdi_service/gnss_interface_impl.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/location/gnss/hdi_service/gnss_interface_impl.cpp b/location/gnss/hdi_service/gnss_interface_impl.cpp index eacc1aeb2d..00fd6168b6 100644 --- a/location/gnss/hdi_service/gnss_interface_impl.cpp +++ b/location/gnss/hdi_service/gnss_interface_impl.cpp @@ -630,7 +630,6 @@ void GnssInterfaceImpl::ResetGnss() ResetGnssDeathRecipient(); StopGnss(GNSS_START_TYPE_NORMAL); DisableGnssMeasurement(); - DisableGnss(); } } // V2_0 } // Gnss -- Gitee From c9a760f56391c72391e97e58ab55538be68cff88 Mon Sep 17 00:00:00 2001 From: liufeng Date: Sat, 17 Aug 2024 09:44:18 +0800 Subject: [PATCH 0235/1485] =?UTF-8?q?=E6=96=B0=E5=A2=9E=EF=BC=B4=EF=BC=A4?= =?UTF-8?q?=EF=BC=A4=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E6=8F=90=E5=8D=87?= =?UTF-8?q?=E5=88=86=E6=94=AF=E8=A6=86=E7=9B=96=E7=8E=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../src/camera_metadata_info_uttest.cpp | 156 ++++++++++++++++++ 1 file changed, 156 insertions(+) diff --git a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp index 8f9709a7fc..3874cf9e34 100644 --- a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp +++ b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp @@ -113,3 +113,159 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_004, TestSize.Level1) EXPECT_NE(header1, nullptr); EXPECT_NE(header2, nullptr); } + +/** + * @tc.name: Camera_Metedate_Info_005 + * @tc.desc: get method test + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_005, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_005 start..."); + FreeCameraMetadataBuffer(nullptr); +} + +/** + * @tc.name: Camera_Metedate_Info_006 + * @tc.desc: get method test + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_006, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_006 start..."); + int ret = DeleteCameraMetadataItem(nullptr, 131071); + EXPECT_EQ(ret, 2); +} + +/** + * @tc.name: Camera_Metedate_Info_007 + * @tc.desc: dataCount = 1, item = 18, data = nullptr + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_007, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_007 start..."); + common_metadata_header_t *header1 = new common_metadata_header_t; + dst->item_count = 1; + int ret = UpdateCameraMetadataItem(dst, 18, nullptr, 1, nullptr); + EXPECT_EQ(ret, 2); +} + +/** + * @tc.name: Camera_Metedate_Info_008 + * @tc.desc: dataCount = 1, item - -131071, data = nullptr + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_008, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_008 start..."); + common_metadata_header_t *header1 = new common_metadata_header_t; + dst->item_count = 1; + int ret = UpdateCameraMetadataItem(dst, -131071, nullptr, 1, nullptr); + EXPECT_EQ(ret, 2); +} + +/** + * @tc.name: Camera_Metedate_Info_009 + * @tc.desc: dataCount = 0, item = -131071 + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_009, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_009 start..."); + common_metadata_header_t *header1 = new common_metadata_header_t; + dst->item_count = 1; + int32_t value = 0; + int ret = UpdateCameraMetadataItem(dst, -131071, &value, 1, nullptr); + EXPECT_EQ(ret, 2); +} + +/** + * @tc.name: Camera_Metedate_Info_010 + * @tc.desc: index = 50, dataCount = 1, data = 0 + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_010, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_010 start..."); + common_metadata_header_t *header1 = new common_metadata_header_t; + dst->item_count = 1; + int32_t value = 0; + int ret = UpdateCameraMetadataItem(dst, 50, &value, 1, nullptr); + EXPECT_EQ(ret, 2); +} + +/** + * @tc.name: Camera_Metedate_Info_011 + * @tc.desc: index = 50, dataCount = 1, data = 0 + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_011, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_011 start..."); + + auto metaData = make_shared(100, 200); + float jpegGpsCoordinates[5] = {0}; + int ret = metaData->addEntry(OHOS_JPEG_GPS_COORDINATES, jpegGpsCoordinates, 5); + EXPECT_NE(ret, false); + + int32_t value = 0; + ret = UpdateCameraMetadataItemByIndex(metaData->get(), 50, &value, 50, nullptr); + EXPECT_NE(ret, 0); + ret = UpdateCameraMetadataItemByIndex(metaData->get(), 0, &value, 5, nullptr); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name: Camera_Metedate_Info_012 + * @tc.desc: index = 50, dataCount = 1, data = 0 + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_012 start..."); + + int32_t ret; + uint32_t index = 0; + auto metaData = make_shared(100, 200); + int8_t cameraType[] = {10, 30}; + int32_t cameraTpsRange[] = {10, 30}; + camera_metadata_item_item_t *item = new camera_metadata_item_item_t; + + ret = metaData->addEntry(OHOS_ABILITY_FPS_RANGES, cameraFpsRange, 2); + EXPECT_EQ(ret, true); + ret = metaData->addEntry(OHOS_ABILITY_CAMERA_TYPE, cameraType, 2); + EXPECT_EQ(ret, true); + camera_metadata_header_t *header1 = metaData->get(); + + ret = GetCamereaMetadataItem(header1, 50, item); + EXPECT_EQ(ret, 2); + ret = metaData->FindCameraMetadataItemIndex(header1, 0, &index, true); + EXPECT_EQ(ret, 3); +} + +/** + * @tc.name: Camera_Metedate_Info_013 + * @tc.desc: index = 50, dataCount = 1, data = 0 + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_013, TestSize.Level1) +{ + printf("CameraMetadataOperatorTest Camera_Metedate_Info_013 start..."); + + int32_t ret; + int32_t value = 0; + CameraMetadata *cameraMetadata = new CameraMetadata(10, 40); + + ret = cameraMetadata->updateEntry(OHOS_ABILITY_MOON_CAPTURE_BOOST, &value, 0); + EXPECT_EQ(ret false); +} \ No newline at end of file -- Gitee From ce24dd5900cf7ab326f1a3920b4d75ee4a76596d Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Fri, 16 Aug 2024 08:19:27 +0000 Subject: [PATCH 0236/1485] interface service modify Signed-off-by: yuzhiqiang --- usb/hdi_service/src/usb_interface_driver.cpp | 36 +++++++++++++++----- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/usb/hdi_service/src/usb_interface_driver.cpp b/usb/hdi_service/src/usb_interface_driver.cpp index 6431b42297..581024df64 100644 --- a/usb/hdi_service/src/usb_interface_driver.cpp +++ b/usb/hdi_service/src/usb_interface_driver.cpp @@ -36,8 +36,6 @@ struct HdfUsbInterfaceHost { static int32_t UsbInterfaceDriverDispatch( struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { - auto *hdfUsbInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUsbInterfaceHost, ioService); - OHOS::MessageParcel *dataParcel = nullptr; OHOS::MessageParcel *replyParcel = nullptr; OHOS::MessageOption option; @@ -51,6 +49,16 @@ static int32_t UsbInterfaceDriverDispatch( return HDF_ERR_INVALID_PARAM; } + if (client == nullptr || client->device == nullptr || client->device->service == nullptr) { + HDF_LOGE("%{public}s:invalid param", __func__); + return HDF_ERR_INVALID_PARAM; + } + + auto *hdfUsbInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUsbInterfaceHost, ioService); + if (hdfUsbInterfaceHost == nullptr || hdfUsbInterfaceHost->stub == nullptr) { + HDF_LOGE("%{public}s:host or stub are nullptr", __func__); + return HDF_ERR_INVALID_PARAM; + } return hdfUsbInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option); } @@ -96,33 +104,43 @@ static int HdfUsbInterfaceDriverBind(struct HdfDeviceObject * const deviceObject hdfUsbInterfaceHost = nullptr; return HDF_FAILURE; } - deviceObject->service = &hdfUsbInterfaceHost->ioService; sptr impl = static_cast(serviceImpl.GetRefPtr()); impl->device_ = deviceObject; int32_t ret = UsbImpl::UsbdEventHandle(impl); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: UsbdEventHandle failed", __func__); + hdfUsbInterfaceHost->stub = nullptr; delete hdfUsbInterfaceHost; hdfUsbInterfaceHost = nullptr; return HDF_FAILURE; } + + deviceObject->service = &hdfUsbInterfaceHost->ioService; return HDF_SUCCESS; } -static void HdfUsbInterfaceDriverRelease(struct HdfDeviceObject * const deviceObject) +static void HdfUsbInterfaceDriverRelease(struct HdfDeviceObject *const deviceObject) { - if (deviceObject->service == nullptr) { + int32_t ret = UsbImpl::UsbdEventHandleRelease(); + if (ret != HDF_SUCCESS) { + HDF_LOGW("%{public}s:UsbdEventHandleRelease ret=%{public}d", __func__, ret); + } + + if (deviceObject == nullptr || deviceObject->service == nullptr) { HDF_LOGE("HdfUsbInterfaceDriverRelease not initted"); return; } - int32_t ret = UsbImpl::UsbdEventHandleRelease(); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s:UsbdEventHandleRelease ret=%{public}d", __func__, ret); - } auto *hdfUsbInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfUsbInterfaceHost, ioService); + if (hdfUsbInterfaceHost == nullptr) { + HDF_LOGE("%{public}s:invalid param", __func__); + return; + } delete hdfUsbInterfaceHost; + hdfUsbInterfaceHost = nullptr; + deviceObject->service = nullptr; + return; } static struct HdfDriverEntry g_usbInterfaceDriverEntry = { -- Gitee From c2a1a20caec548709c7f14e0462ee2ffb9eba350 Mon Sep 17 00:00:00 2001 From: hxf233333 Date: Tue, 6 Aug 2024 17:10:04 +0800 Subject: [PATCH 0237/1485] fix: modify IsValidType check Signed-off-by: hxf233333 --- .../hdi_service/src/running_lock_impl.cpp | 3 --- .../src/hdf_power_runninglock_test.cpp | 19 +++++++++++++------ 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/power/interfaces/hdi_service/src/running_lock_impl.cpp b/power/interfaces/hdi_service/src/running_lock_impl.cpp index 0777e602a2..05dbe446da 100644 --- a/power/interfaces/hdi_service/src/running_lock_impl.cpp +++ b/power/interfaces/hdi_service/src/running_lock_impl.cpp @@ -171,10 +171,7 @@ bool RunningLockImpl::IsValidType(RunningLockType type, PowerHdfState state) { switch (state) { case PowerHdfState::SLEEP: - return type == RUNNINGLOCK_BACKGROUND_AUDIO; case PowerHdfState::INACTIVE: - return type == RUNNINGLOCK_BACKGROUND_PHONE || type == RUNNINGLOCK_BACKGROUND_NOTIFICATION || - type == RUNNINGLOCK_BACKGROUND_AUDIO || type == RUNNINGLOCK_BACKGROUND_TASK; case PowerHdfState::AWAKE: return type == RUNNINGLOCK_BACKGROUND_PHONE || type == RUNNINGLOCK_BACKGROUND_NOTIFICATION || type == RUNNINGLOCK_BACKGROUND_AUDIO || type == RUNNINGLOCK_BACKGROUND_SPORT || diff --git a/power/test/unittest/src/hdf_power_runninglock_test.cpp b/power/test/unittest/src/hdf_power_runninglock_test.cpp index 8c87cbe586..f1fcf40926 100644 --- a/power/test/unittest/src/hdf_power_runninglock_test.cpp +++ b/power/test/unittest/src/hdf_power_runninglock_test.cpp @@ -469,10 +469,12 @@ HWTEST_F(HdfPowerRunningLockTest, HdfPowerRunningLockTest012, TestSize.Level1) runinglockInfo.timeoutMs = RUNNINGLOCK_TIMEOUT_NONE; runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT; EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); @@ -481,7 +483,8 @@ HWTEST_F(HdfPowerRunningLockTest, HdfPowerRunningLockTest012, TestSize.Level1) EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); } /** @@ -500,10 +503,14 @@ HWTEST_F(HdfPowerRunningLockTest, HdfPowerRunningLockTest013, TestSize.Level1) runinglockInfo.timeoutMs = RUNNINGLOCK_TIMEOUT_NONE; runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); + runinglockInfo.name = setLockName + "sport.13"; + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); + runinglockInfo.name = setLockName + "navigation.13"; + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK; runinglockInfo.name = setLockName + "task.13"; @@ -963,7 +970,7 @@ HWTEST_F(HdfPowerRunningLockTest, HdfPowerRunningLockTest022, TestSize.Level1) EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::UnholdLock(runinglockInfo2)); powerState = PowerHdfState::SLEEP; - EXPECT_NE(HDF_SUCCESS, RunningLockImpl::HoldLock(runinglockInfo1, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::HoldLock(runinglockInfo1, powerState)); EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::UnholdLock(runinglockInfo1)); } } \ No newline at end of file -- Gitee From f6c8461aecc158574df41b1cfaec9499c8d9dad0 Mon Sep 17 00:00:00 2001 From: liufeng Date: Sat, 17 Aug 2024 13:48:36 +0800 Subject: [PATCH 0238/1485] =?UTF-8?q?=E6=96=B0=E5=A2=9ETDD=E6=B5=8B?= =?UTF-8?q?=E8=AF=95=E7=94=A8=E4=BE=8B=E6=8F=90=E5=8D=87=E5=88=86=E6=94=AF?= =?UTF-8?q?=E8=A6=86=E7=9B=96=E7=8E=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- .../src/camera_metadata_info_uttest.cpp | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp index 3874cf9e34..e1934b5625 100644 --- a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp +++ b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp @@ -116,25 +116,25 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_004, TestSize.Level1) /** * @tc.name: Camera_Metedate_Info_005 - * @tc.desc: get method test + * @tc.desc: dst = nullptr * @tc.size: MediumTest * @tc.type: Function */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_005, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_005 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_005 start..."); FreeCameraMetadataBuffer(nullptr); } /** * @tc.name: Camera_Metedate_Info_006 - * @tc.desc: get method test + * @tc.desc: dst = nullptr, item = 131071 * @tc.size: MediumTest * @tc.type: Function */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_006, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_006 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_006 start..."); int ret = DeleteCameraMetadataItem(nullptr, 131071); EXPECT_EQ(ret, 2); } @@ -147,8 +147,8 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_006, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_007, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_007 start..."); - common_metadata_header_t *header1 = new common_metadata_header_t; + printf("CameraMetadataInfoTest Camera_Metedate_Info_007 start..."); + common_metadata_header_t *dst = new common_metadata_header_t; dst->item_count = 1; int ret = UpdateCameraMetadataItem(dst, 18, nullptr, 1, nullptr); EXPECT_EQ(ret, 2); @@ -156,14 +156,14 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_007, TestSize.Level1) /** * @tc.name: Camera_Metedate_Info_008 - * @tc.desc: dataCount = 1, item - -131071, data = nullptr + * @tc.desc: dataCount = 1, item = -131071, data = nullptr * @tc.size: MediumTest * @tc.type: Function */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_008, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_008 start..."); - common_metadata_header_t *header1 = new common_metadata_header_t; + printf("CameraMetadataInfoTest Camera_Metedate_Info_008 start..."); + common_metadata_header_t *dst = new common_metadata_header_t; dst->item_count = 1; int ret = UpdateCameraMetadataItem(dst, -131071, nullptr, 1, nullptr); EXPECT_EQ(ret, 2); @@ -177,11 +177,11 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_008, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_009, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_009 start..."); - common_metadata_header_t *header1 = new common_metadata_header_t; + printf("CameraMetadataInfoTest Camera_Metedate_Info_009 start..."); + common_metadata_header_t *dst = new common_metadata_header_t; dst->item_count = 1; int32_t value = 0; - int ret = UpdateCameraMetadataItem(dst, -131071, &value, 1, nullptr); + int ret = UpdateCameraMetadataItem(dst, -131071, &value, 0, nullptr); EXPECT_EQ(ret, 2); } @@ -193,11 +193,11 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_009, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_010, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_010 start..."); - common_metadata_header_t *header1 = new common_metadata_header_t; + printf("CameraMetadataInfoTest Camera_Metedate_Info_010 start..."); + common_metadata_header_t *dst = new common_metadata_header_t; dst->item_count = 1; int32_t value = 0; - int ret = UpdateCameraMetadataItem(dst, 50, &value, 1, nullptr); + int ret = UpdateCameraMetadataItemByIndex(dst, 50, &value, 1, nullptr); // 1009 EXPECT_EQ(ret, 2); } @@ -209,7 +209,7 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_010, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_011, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_011 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_011 start..."); auto metaData = make_shared(100, 200); float jpegGpsCoordinates[5] = {0}; @@ -231,20 +231,20 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_011, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_012 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_012 start..."); int32_t ret; uint32_t index = 0; auto metaData = make_shared(100, 200); int8_t cameraType[] = {10, 30}; - int32_t cameraTpsRange[] = {10, 30}; + int32_t cameraFpsRange[] = {10, 30}; camera_metadata_item_item_t *item = new camera_metadata_item_item_t; ret = metaData->addEntry(OHOS_ABILITY_FPS_RANGES, cameraFpsRange, 2); EXPECT_EQ(ret, true); ret = metaData->addEntry(OHOS_ABILITY_CAMERA_TYPE, cameraType, 2); EXPECT_EQ(ret, true); - camera_metadata_header_t *header1 = metaData->get(); + common_metadata_header_t *header1 = metaData->get(); ret = GetCamereaMetadataItem(header1, 50, item); EXPECT_EQ(ret, 2); @@ -253,19 +253,19 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) } /** - * @tc.name: Camera_Metedate_Info_013 + * @tc.name: Camera_Metedate_Info_014 * @tc.desc: index = 50, dataCount = 1, data = 0 * @tc.size: MediumTest * @tc.type: Function */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_013, TestSize.Level1) { - printf("CameraMetadataOperatorTest Camera_Metedate_Info_013 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_013 start..."); int32_t ret; int32_t value = 0; CameraMetadata *cameraMetadata = new CameraMetadata(10, 40); ret = cameraMetadata->updateEntry(OHOS_ABILITY_MOON_CAPTURE_BOOST, &value, 0); - EXPECT_EQ(ret false); + EXPECT_EQ(ret, false); } \ No newline at end of file -- Gitee From 544ca67f1c858cfab74a87fec6d6de12ab008260 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Sat, 17 Aug 2024 05:52:17 +0000 Subject: [PATCH 0239/1485] update camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- .../test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp index e1934b5625..3b20f1c2d7 100644 --- a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp +++ b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp @@ -260,7 +260,7 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) */ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_013, TestSize.Level1) { - printf("CameraMetadataInfoTest Camera_Metedate_Info_013 start..."); + printf("CameraMetadataInfoTest Camera_Metedate_Info_014 start..."); int32_t ret; int32_t value = 0; -- Gitee From 22b3bcade50c90fc6243dc0bf9904d2c7b0a0272 Mon Sep 17 00:00:00 2001 From: "Wangmingze(Salvatore)" Date: Fri, 16 Aug 2024 18:08:01 +0800 Subject: [PATCH 0240/1485] registerbuffer Signed-off-by: Wangmingze(Salvatore) --- codec/hal/idl_service/BUILD.gn | 2 + .../include/codec_component_service.h | 1 + .../idl_service/include/codec_dyna_buffer.h | 9 +-- .../idl_service/include/codec_handle_buffer.h | 8 +- codec/hal/idl_service/include/icodec_buffer.h | 20 +---- .../src/codec_component_service.cpp | 74 +++++++++++++++++++ .../hal/idl_service/src/codec_dyna_buffer.cpp | 64 ++++++---------- .../idl_service/src/codec_handle_buffer.cpp | 55 ++++---------- 8 files changed, 121 insertions(+), 112 deletions(-) diff --git a/codec/hal/idl_service/BUILD.gn b/codec/hal/idl_service/BUILD.gn index d3d0c46201..04e82a65d3 100644 --- a/codec/hal/idl_service/BUILD.gn +++ b/codec/hal/idl_service/BUILD.gn @@ -41,6 +41,8 @@ ohos_shared_library("libcodec_component_manager_service_3.0") { "c_utils:utils", "drivers_interface_codec:libcodec_proxy_3.0", "drivers_interface_display:libdisplay_buffer_proxy_1.0", + "drivers_interface_display:libdisplay_buffer_proxy_1.1", + "drivers_interface_display:libdisplay_composer_proxy_1.0", "graphic_surface:buffer_handle", "hdf_core:libhdf_host", "hdf_core:libhdf_ipc_adapter", diff --git a/codec/hal/idl_service/include/codec_component_service.h b/codec/hal/idl_service/include/codec_component_service.h index 057ccc3178..f8ea35faf8 100644 --- a/codec/hal/idl_service/include/codec_component_service.h +++ b/codec/hal/idl_service/include/codec_component_service.h @@ -57,6 +57,7 @@ public: const std::string &GetComponentCompName() const; void GetComponentNode(std::shared_ptr &dumpNode_); + bool ReWrapNativeBufferInOmxBuffer(const OmxCodecBuffer &inBuffer); private: void SetComponentRole(); void ReleaseCache(); diff --git a/codec/hal/idl_service/include/codec_dyna_buffer.h b/codec/hal/idl_service/include/codec_dyna_buffer.h index 89215b2afb..4f79dbf6e7 100644 --- a/codec/hal/idl_service/include/codec_dyna_buffer.h +++ b/codec/hal/idl_service/include/codec_dyna_buffer.h @@ -32,14 +32,11 @@ public: uint8_t *GetBuffer() override; protected: - CodecDynaBuffer(struct OmxCodecBuffer &codecBuffer, BufferHandle *bufferHandle); - bool CheckInvalid(struct OmxCodecBuffer &codecBuffer) override; + CodecDynaBuffer(struct OmxCodecBuffer &codecBuffer); private: - void ResetBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer); - -private: - std::shared_ptr dynaBuffer_; + DynamicBuffer dynaBuffer_{}; + sptr buffer_; }; } // namespace Omx } // namespace Codec diff --git a/codec/hal/idl_service/include/codec_handle_buffer.h b/codec/hal/idl_service/include/codec_handle_buffer.h index ae180b4912..52cb6ff55c 100644 --- a/codec/hal/idl_service/include/codec_handle_buffer.h +++ b/codec/hal/idl_service/include/codec_handle_buffer.h @@ -33,14 +33,10 @@ public: uint8_t *GetBuffer() override; protected: - CodecHandleBuffer(struct OmxCodecBuffer &codecBuffer, BufferHandle *bufferHandle); - bool CheckInvalid(struct OmxCodecBuffer &codecBuffer) override; + CodecHandleBuffer(struct OmxCodecBuffer &codecBuffer); private: - void ResetBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer); - -private: - BufferHandle *bufferHandle_; + sptr buffer_; }; } // namespace Omx } // namespace Codec diff --git a/codec/hal/idl_service/include/icodec_buffer.h b/codec/hal/idl_service/include/icodec_buffer.h index 0432c9f6a9..35148969a2 100644 --- a/codec/hal/idl_service/include/icodec_buffer.h +++ b/codec/hal/idl_service/include/icodec_buffer.h @@ -30,24 +30,8 @@ namespace OHOS { namespace Codec { namespace Omx { struct DynamicBuffer { - int32_t type; - BufferHandle *bufferHandle; - - DynamicBuffer() : type(0), bufferHandle(nullptr) - {} - ~DynamicBuffer() - { - type = 0; - if (bufferHandle != nullptr) { - FreeBufferHandle(bufferHandle); - } - bufferHandle = nullptr; - } - - DynamicBuffer(const DynamicBuffer& other) = delete; - DynamicBuffer(DynamicBuffer&& other) = delete; - DynamicBuffer& operator=(const DynamicBuffer& other) = delete; - DynamicBuffer& operator=(DynamicBuffer&& other) = delete; + int32_t type = 0; + BufferHandle *bufferHandle = nullptr; }; class ICodecBuffer : public RefBase { diff --git a/codec/hal/idl_service/src/codec_component_service.cpp b/codec/hal/idl_service/src/codec_component_service.cpp index ae415486cf..631a242493 100644 --- a/codec/hal/idl_service/src/codec_component_service.cpp +++ b/codec/hal/idl_service/src/codec_component_service.cpp @@ -20,6 +20,8 @@ #include #include #include +#include "v1_0/display_composer_type.h" +#include "v1_1/imetadata.h" #include "codec_log_wrapper.h" #define AUDIO_CODEC_NAME "OMX.audio" @@ -47,6 +49,69 @@ sptr GetMapperService() return nullptr; } +std::mutex g_metaMtx; +sptr g_metaService; + +sptr GetMetaService() +{ + std::lock_guard lk(g_metaMtx); + if (g_metaService) { + return g_metaService; + } + g_metaService = OHOS::HDI::Display::Buffer::V1_1::IMetadata::Get(true); + if (g_metaService) { + CODEC_LOGI("get IMetadata succ"); + return g_metaService; + } + CODEC_LOGE("get IMetadata failed"); + return nullptr; +} + +void BufferDestructor(BufferHandle* handle) +{ + if (handle == nullptr) { + return; + } + sptr mapper = GetMapperService(); + if (mapper == nullptr) { + return; + } + sptr buffer = new NativeBuffer(); + buffer->SetBufferHandle(handle, true); + mapper->FreeMem(buffer); +} + +bool ReWrapNativeBuffer(sptr& buffer) +{ + if (buffer == nullptr) { + return true; + } + BufferHandle* handle = buffer->Move(); + if (handle == nullptr) { + return true; + } + buffer->SetBufferHandle(handle, true, BufferDestructor); + sptr meta = GetMetaService(); + if (meta == nullptr) { + return false; + } + int32_t ret = meta->RegisterBuffer(buffer); + if (ret != Display::Composer::V1_0::DISPLAY_SUCCESS && + ret != Display::Composer::V1_0::DISPLAY_NOT_SUPPORT) { + CODEC_LOGE("RegisterBuffer failed, ret = %{public}d", ret); + return false; + } + return true; +} + +bool CodecComponentService::ReWrapNativeBufferInOmxBuffer(const OmxCodecBuffer &inBuffer) +{ + if (!isIPCMode_) { + return true; + } + return ReWrapNativeBuffer(const_cast(inBuffer).bufferhandle); +} + CodecComponentService::CodecComponentService(const std::shared_ptr &node, const std::shared_ptr mgr, const std::string name) { @@ -152,6 +217,9 @@ int32_t CodecComponentService::UseBuffer(uint32_t portIndex, const OmxCodecBuffe { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HDFCodecUseBuffer"); CODEC_LOGD("portIndex: [%{public}d]", portIndex); + if (!ReWrapNativeBufferInOmxBuffer(inBuffer)) { + return HDF_FAILURE; + } outBuffer = const_cast(inBuffer); if (outBuffer.fd >= 0 && isIPCMode_ && outBuffer.bufferType != CODEC_BUFFER_TYPE_AVSHARE_MEM_FD && @@ -195,6 +263,9 @@ int32_t CodecComponentService::FreeBuffer(uint32_t portIndex, const OmxCodecBuff int32_t CodecComponentService::EmptyThisBuffer(const OmxCodecBuffer &buffer) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HDFCodecEmptyThisBuffer"); + if (!ReWrapNativeBufferInOmxBuffer(buffer)) { + return HDF_FAILURE; + } OmxCodecBuffer &bufferTemp = const_cast(buffer); int32_t ret = node_->EmptyThisBuffer(bufferTemp); if (isIPCMode_ && bufferTemp.fd >= 0) { @@ -208,6 +279,9 @@ int32_t CodecComponentService::EmptyThisBuffer(const OmxCodecBuffer &buffer) int32_t CodecComponentService::FillThisBuffer(const OmxCodecBuffer &buffer) { HITRACE_METER_NAME(HITRACE_TAG_HDF, "HDFCodecFillThisBuffer"); + if (!ReWrapNativeBufferInOmxBuffer(buffer)) { + return HDF_FAILURE; + } OmxCodecBuffer &bufferTemp = const_cast(buffer); int32_t ret = node_->FillThisBuffer(bufferTemp); if (isIPCMode_ && bufferTemp.fd >= 0) { diff --git a/codec/hal/idl_service/src/codec_dyna_buffer.cpp b/codec/hal/idl_service/src/codec_dyna_buffer.cpp index 2d16cd973b..c9439fc65c 100644 --- a/codec/hal/idl_service/src/codec_dyna_buffer.cpp +++ b/codec/hal/idl_service/src/codec_dyna_buffer.cpp @@ -23,27 +23,20 @@ using namespace OHOS::HDI::Codec::V3_0; namespace OHOS { namespace Codec { namespace Omx { -CodecDynaBuffer::CodecDynaBuffer(struct OmxCodecBuffer &codecBuffer, BufferHandle *bufferHandle) +CodecDynaBuffer::CodecDynaBuffer(struct OmxCodecBuffer &codecBuffer) : ICodecBuffer(codecBuffer) { - dynaBuffer_ = std::make_shared(); - dynaBuffer_->bufferHandle = bufferHandle; } CodecDynaBuffer::~CodecDynaBuffer() { - dynaBuffer_ = nullptr; } sptr CodecDynaBuffer::Create(struct OmxCodecBuffer &codecBuffer) { - BufferHandle *bufferHandle = nullptr; - if (codecBuffer.bufferhandle) { - bufferHandle = codecBuffer.bufferhandle->Move(); - codecBuffer.bufferhandle = nullptr; - } + codecBuffer.bufferhandle = nullptr; codecBuffer.allocLen = sizeof(DynamicBuffer); - CodecDynaBuffer *buffer = new CodecDynaBuffer(codecBuffer, bufferHandle); + CodecDynaBuffer *buffer = new CodecDynaBuffer(codecBuffer); return sptr(buffer); } @@ -54,8 +47,12 @@ int32_t CodecDynaBuffer::FillOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX_B return HDF_ERR_INVALID_PARAM; } - if (dynaBuffer_->bufferHandle == nullptr) { - dynaBuffer_->bufferHandle = codecBuffer.bufferhandle->Move(); + if (buffer_ == nullptr && codecBuffer.bufferhandle != nullptr) { + BufferHandle* handle = codecBuffer.bufferhandle->GetBufferHandle(); + if (handle != nullptr) { + buffer_ = codecBuffer.bufferhandle; + dynaBuffer_.bufferHandle = handle; + } } int fenceFd = codecBuffer.fenceFd; @@ -76,7 +73,17 @@ int32_t CodecDynaBuffer::EmptyOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX_ CODEC_LOGE("CheckInvalid return false"); return HDF_ERR_INVALID_PARAM; } - ResetBuffer(codecBuffer, omxBuffer); + buffer_ = nullptr; + dynaBuffer_.bufferHandle = nullptr; + codecBuffer.filledLen = 0; + if (codecBuffer.bufferhandle != nullptr) { + BufferHandle* handle = codecBuffer.bufferhandle->GetBufferHandle(); + if (handle != nullptr) { + buffer_ = codecBuffer.bufferhandle; + dynaBuffer_.bufferHandle = handle; + codecBuffer.filledLen = sizeof(DynamicBuffer); + } + } int fence = codecBuffer.fenceFd; if (fence >= 0) { @@ -98,9 +105,7 @@ int32_t CodecDynaBuffer::FreeBuffer(struct OmxCodecBuffer &codecBuffer) return HDF_ERR_INVALID_PARAM; } - codecBuffer.bufferhandle = nullptr; - dynaBuffer_ = nullptr; - + buffer_ = nullptr; return HDF_SUCCESS; } @@ -116,34 +121,9 @@ int32_t CodecDynaBuffer::FillOmxBufferDone(OMX_BUFFERHEADERTYPE &omxBuffer) uint8_t *CodecDynaBuffer::GetBuffer() { - return reinterpret_cast(dynaBuffer_.get()); + return reinterpret_cast(&dynaBuffer_); } -bool CodecDynaBuffer::CheckInvalid(struct OmxCodecBuffer &codecBuffer) -{ - if (!ICodecBuffer::CheckInvalid(codecBuffer) || dynaBuffer_ == nullptr) { - CODEC_LOGE("dynaBuffer_ is null or CheckInvalid return false"); - return false; - } - return true; -} - -void CodecDynaBuffer::ResetBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer) -{ - (void)omxBuffer; - if (codecBuffer.bufferhandle == nullptr) { - return; - } - auto bufferHandle = codecBuffer.bufferhandle->Move(); - codecBuffer.bufferhandle = nullptr; - - // if recv new BufferHandle, save it, but do not need to save to omxBuffer - if (dynaBuffer_->bufferHandle != nullptr) { - FreeBufferHandle(dynaBuffer_->bufferHandle); - } - dynaBuffer_->bufferHandle = bufferHandle; - codecBuffer.filledLen = sizeof(DynamicBuffer); -} } // namespace Omx } // namespace Codec } // namespace OHOS \ No newline at end of file diff --git a/codec/hal/idl_service/src/codec_handle_buffer.cpp b/codec/hal/idl_service/src/codec_handle_buffer.cpp index fd40f1c3dc..a1ad217b27 100644 --- a/codec/hal/idl_service/src/codec_handle_buffer.cpp +++ b/codec/hal/idl_service/src/codec_handle_buffer.cpp @@ -23,27 +23,29 @@ using namespace OHOS::HDI::Codec::V3_0; namespace OHOS { namespace Codec { namespace Omx { -CodecHandleBuffer::CodecHandleBuffer(struct OmxCodecBuffer &codecBuffer, BufferHandle *bufferHandle) - : ICodecBuffer(codecBuffer), bufferHandle_(bufferHandle) -{} +CodecHandleBuffer::CodecHandleBuffer(struct OmxCodecBuffer &codecBuffer) + : ICodecBuffer(codecBuffer) +{ + buffer_ = codecBuffer.bufferhandle; +} CodecHandleBuffer::~CodecHandleBuffer() { - if (bufferHandle_ != nullptr) { - FreeBufferHandle(bufferHandle_); - bufferHandle_ = nullptr; - } } sptr CodecHandleBuffer::Create(struct OmxCodecBuffer &codecBuffer) { if (codecBuffer.bufferhandle == nullptr) { + CODEC_LOGE("nativebuffer is null"); + return nullptr; + } + BufferHandle *bufferHandle = codecBuffer.bufferhandle->GetBufferHandle(); + if (bufferHandle == nullptr) { CODEC_LOGE("bufferHandle is null"); return nullptr; } - BufferHandle *bufferHandle = codecBuffer.bufferhandle->Move(); + CodecHandleBuffer *buffer = new CodecHandleBuffer(codecBuffer); codecBuffer.bufferhandle = nullptr; - CodecHandleBuffer *buffer = new CodecHandleBuffer(codecBuffer, bufferHandle); return sptr(buffer); } @@ -53,7 +55,6 @@ int32_t CodecHandleBuffer::FillOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX CODEC_LOGE("CheckInvalid return false or mem has no right to write "); return HDF_ERR_INVALID_PARAM; } - ResetBuffer(codecBuffer, omxBuffer); int fenceFd = codecBuffer.fenceFd; if (fenceFd >= 0) { @@ -82,10 +83,7 @@ int32_t CodecHandleBuffer::FreeBuffer(struct OmxCodecBuffer &codecBuffer) return HDF_ERR_INVALID_PARAM; } codecBuffer.bufferhandle = nullptr; - if (bufferHandle_ != nullptr) { - FreeBufferHandle(bufferHandle_); - bufferHandle_ = nullptr; - } + buffer_ = nullptr; return HDF_SUCCESS; } @@ -104,35 +102,12 @@ int32_t CodecHandleBuffer::FillOmxBufferDone(OMX_BUFFERHEADERTYPE &omxBuffer) uint8_t *CodecHandleBuffer::GetBuffer() { - return reinterpret_cast(bufferHandle_); -} - -bool CodecHandleBuffer::CheckInvalid(struct OmxCodecBuffer &codecBuffer) -{ - if (!ICodecBuffer::CheckInvalid(codecBuffer) || bufferHandle_ == nullptr) { - CODEC_LOGE("bufferHandle_ is null or CheckInvalid return false"); - return false; + if (buffer_ == nullptr) { + return nullptr; } - return true; + return reinterpret_cast(buffer_->GetBufferHandle()); } -void CodecHandleBuffer::ResetBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer) -{ - if (codecBuffer.bufferhandle == nullptr) { - return; - } - auto bufferHandle = codecBuffer.bufferhandle->Move(); - codecBuffer.bufferhandle = nullptr; - // if recv new BufferHandle, save it, and save the new bufferhandle to omxbuffer - if (bufferHandle == nullptr) { - return; - } - if (bufferHandle_ != nullptr) { - FreeBufferHandle(bufferHandle_); - } - bufferHandle_ = bufferHandle; - omxBuffer.pBuffer = reinterpret_cast(bufferHandle_); -} } // namespace Omx } // namespace Codec } // namespace OHOS \ No newline at end of file -- Gitee From 10cfe999d4ae024edd669caec2362d2557e44850 Mon Sep 17 00:00:00 2001 From: shilong Date: Sat, 17 Aug 2024 10:11:24 +0800 Subject: [PATCH 0241/1485] =?UTF-8?q?=E8=8A=AF=E7=89=87=E7=BB=84=E4=BB=B6?= =?UTF-8?q?=E7=8B=AC=E7=AB=8B=E7=BC=96=E8=AF=91=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/test/benchmarktest/BUILD.gn | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/input/test/benchmarktest/BUILD.gn b/input/test/benchmarktest/BUILD.gn index 02a9cc4a44..4085ceacb0 100644 --- a/input/test/benchmarktest/BUILD.gn +++ b/input/test/benchmarktest/BUILD.gn @@ -38,11 +38,6 @@ ohos_benchmarktest("hdf_input_benchmark_test") { "-fno-strict-aliasing", ] - deps = [ - "//third_party/benchmark", - "//third_party/googletest:gmock_main", - ] - if (is_standard_system) { external_deps = [ "c_utils:utils", @@ -54,12 +49,15 @@ ohos_benchmarktest("hdf_input_benchmark_test") { } else { external_deps = [ "hilog:libhilog" ] } - external_deps += [ "ipc:ipc_single" ] + external_deps += [ + "benchmark:benchmark", + "googletest:gmock_main", + "ipc:ipc_single", + ] } ohos_benchmarktest("hid_ddk_benchmark_test") { module_out_path = "drivers_peripheral_input/input" - include_dirs = [] sources = [ "hid_ddk_benchmark_test.cpp" ] cflags = [ @@ -71,17 +69,14 @@ ohos_benchmarktest("hid_ddk_benchmark_test") { "-fno-strict-aliasing", ] - deps = [ - "//third_party/benchmark", - "//third_party/googletest:gmock_main", - ] - external_deps = [ "access_token:libaccesstoken_sdk", "access_token:libnativetoken", "access_token:libtoken_setproc", + "benchmark:benchmark", "c_utils:utils", "drivers_interface_input:libhid_ddk_proxy_1.0", + "googletest:gmock_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", -- Gitee From cbbeeb3f80d1be82fa3888567cda8c6af61cf158 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 17 Aug 2024 15:25:20 +0800 Subject: [PATCH 0242/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- audio/hdi_service/primary/BUILD.gn | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/audio/hdi_service/primary/BUILD.gn b/audio/hdi_service/primary/BUILD.gn index 814292de41..683a94e808 100644 --- a/audio/hdi_service/primary/BUILD.gn +++ b/audio/hdi_service/primary/BUILD.gn @@ -47,6 +47,18 @@ ohos_shared_library("audio_primary_driver") { ohos_shared_library("audio_manager_service_4.0") { sources = [ "audio_manager_service.c" ] + cflags = [ + "-fstack-protector-strong", + "-D_FORTIFY_SOURCE=2", + "-O2", + ] + + cflags_cc = [ + "-fstack-protector-strong", + "-D_FORTIFY_SOURCE=2", + "-O2", + ] + if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", -- Gitee From 93a12e1b5af61c458ea0e06baf0f5a98d54d8694 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Sat, 17 Aug 2024 08:12:07 +0000 Subject: [PATCH 0243/1485] update camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- .../hdi/metadata_test/src/camera_metadata_info_uttest.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp index 3b20f1c2d7..93db9036fa 100644 --- a/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp +++ b/camera/test/hdi/metadata_test/src/camera_metadata_info_uttest.cpp @@ -238,7 +238,7 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) auto metaData = make_shared(100, 200); int8_t cameraType[] = {10, 30}; int32_t cameraFpsRange[] = {10, 30}; - camera_metadata_item_item_t *item = new camera_metadata_item_item_t; + camera_metadata_item_t *item = new camera_metadata_item_t; ret = metaData->addEntry(OHOS_ABILITY_FPS_RANGES, cameraFpsRange, 2); EXPECT_EQ(ret, true); @@ -246,7 +246,7 @@ HWTEST_F(CameraMetadataInfoTest, Camera_Metedate_Info_012, TestSize.Level1) EXPECT_EQ(ret, true); common_metadata_header_t *header1 = metaData->get(); - ret = GetCamereaMetadataItem(header1, 50, item); + ret = GetCameraMetadataItem(header1, 50, item); EXPECT_EQ(ret, 2); ret = metaData->FindCameraMetadataItemIndex(header1, 0, &index, true); EXPECT_EQ(ret, 3); -- Gitee From 475532fd9ea8936bea1c2e9ae47aaa49fcba9efd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Sat, 17 Aug 2024 09:15:31 +0000 Subject: [PATCH 0244/1485] update camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp index 3c4d4bbb2e..3709b889ba 100644 --- a/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_professional_uttest_v1_3.cpp @@ -428,6 +428,9 @@ HWTEST_F(CameraProfessionalUtTestV1_3, Camera_Professional_Hdi_V1_3_008, TestSiz CAMERA_LOGI("OHOS_CAMERA_CENTER_WEIGHTED_METERING mode is supported!"); } } + } else { + printf("get tag failed.\n"); + return; } for (uint8_t i = 0;i < entry.count;i++) { -- Gitee From da24bfafde5993bf60ffb1c7753f79191da0708e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Sat, 17 Aug 2024 09:17:17 +0000 Subject: [PATCH 0245/1485] update camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 08baf64b38..cb9026035e 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -1378,7 +1378,10 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_037, TestSize.Level1) EXPECT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LIGHT_PAINTING_TYPE, &entry); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) { + printf("get tag failed.\n"); + return; + } cameraTest->imageDataSaveSwitch = SWITCH_ON; cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); -- Gitee From 305438aad26ff0ce35f0faa3a3eef45bba85b086 Mon Sep 17 00:00:00 2001 From: liufeng Date: Sat, 17 Aug 2024 17:39:50 +0800 Subject: [PATCH 0246/1485] =?UTF-8?q?=E8=8A=AF=E7=89=87=E7=BB=84=E4=BB=B6?= =?UTF-8?q?=E7=8B=AC=E7=AB=8B=E6=9E=84=E5=BB=BA=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/hdi_service/v1_0/BUILD.gn | 1 - camera/test/hdi/metadata_test/BUILD.gn | 14 +++++--------- camera/test/hdi/sequenceable_test/BUILD.gn | 1 - camera/test/hdi/v1_0/BUILD.gn | 14 +++++--------- camera/test/hdi/v1_1/BUILD.gn | 14 +++++--------- camera/test/hdi/v1_2/BUILD.gn | 1 - camera/test/ut/buffer_manager/BUILD.gn | 13 +++---------- camera/test/ut/usb_camera/BUILD.gn | 12 +++--------- camera/test/ut/v4l2/BUILD.gn | 13 +++---------- .../platform/v4l2/src/driver_adapter/BUILD.gn | 1 - camera/vdi_base/common/metadata_manager/BUILD.gn | 1 - camera/vdi_base/common/pipeline_core/BUILD.gn | 1 - camera/vdi_base/usb_camera/BUILD.gn | 2 -- .../platform/v4l2/src/driver_adapter/BUILD.gn | 1 - camera/vdi_base/usb_camera/camera_config/BUILD.gn | 2 -- .../vdi_base/usb_camera/metadata_manager/BUILD.gn | 1 - camera/vdi_base/usb_camera/pipeline_core/BUILD.gn | 1 - camera/vdi_base/usb_camera/vdi_impl/BUILD.gn | 1 - 18 files changed, 24 insertions(+), 70 deletions(-) diff --git a/camera/hdi_service/v1_0/BUILD.gn b/camera/hdi_service/v1_0/BUILD.gn index 6e1fb07d56..b2d2dab213 100644 --- a/camera/hdi_service/v1_0/BUILD.gn +++ b/camera/hdi_service/v1_0/BUILD.gn @@ -61,7 +61,6 @@ if (defined(ohos_lite)) { } } else { import("//build/ohos.gni") - import("../../../../hdf_core/adapter/uhdf2/uhdf.gni") config("camhdi_impl_config") { visibility = [ ":*" ] diff --git a/camera/test/hdi/metadata_test/BUILD.gn b/camera/test/hdi/metadata_test/BUILD.gn index 11ea227c8a..d027645298 100644 --- a/camera/test/hdi/metadata_test/BUILD.gn +++ b/camera/test/hdi/metadata_test/BUILD.gn @@ -16,7 +16,6 @@ camera_test_path = "//drivers/peripheral/camera/test/hdi/" import("//build/ohos.gni") import("//build/test.gni") -import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -44,19 +43,16 @@ ohos_unittest("camera_metadata_operator_ut") { include_dirs = [ # common includes "$camera_test_path/metadata_test/include", - "//third_party/googletest/googletest/include", - "$camera_path/../../../display/interfaces/include", - "$camera_path/../../../display/hdi_service/gralloc/include", "$camera_path/../../interfaces/include", "$camera_path/metadata_manager/include", "$camera_path/include", ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest", - "//third_party/googletest:gtest_main", - ] + # deps = [ + # "//third_party/googletest:gmock_main", + # "//third_party/googletest:gtest", + # "//third_party/googletest:gtest_main", + # ] if (is_standard_system) { external_deps = [ diff --git a/camera/test/hdi/sequenceable_test/BUILD.gn b/camera/test/hdi/sequenceable_test/BUILD.gn index 792d1d5f22..24f99b5bf6 100644 --- a/camera/test/hdi/sequenceable_test/BUILD.gn +++ b/camera/test/hdi/sequenceable_test/BUILD.gn @@ -13,7 +13,6 @@ import("//build/ohos.gni") import("//build/test.gni") -import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") import("../../../camera.gni") module_output_path = "drivers_peripheral_camera/camera" diff --git a/camera/test/hdi/v1_0/BUILD.gn b/camera/test/hdi/v1_0/BUILD.gn index db3295ca02..a8f2bbef50 100644 --- a/camera/test/hdi/v1_0/BUILD.gn +++ b/camera/test/hdi/v1_0/BUILD.gn @@ -86,7 +86,6 @@ if (defined(ohos_lite)) { } else { import("//build/ohos.gni") import("//build/test.gni") - import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -117,18 +116,15 @@ if (defined(ohos_lite)) { include_dirs = [ # common includes "$camera_test_path/v1_0/include", - "//third_party/googletest/googletest/include", - "$camera_path/../../../display/interfaces/include", - "$camera_path/../../../display/hdi_service/gralloc/include", "$camera_path/../../interfaces/include", "$camera_path/include", ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest", - "//third_party/googletest:gtest_main", - ] + # deps = [ + # "//third_party/googletest:gmock_main", + # "//third_party/googletest:gtest", + # "//third_party/googletest:gtest_main", + # ] if (is_standard_system) { external_deps = [ diff --git a/camera/test/hdi/v1_1/BUILD.gn b/camera/test/hdi/v1_1/BUILD.gn index 7b2d2bf2e3..0a85d6cc07 100644 --- a/camera/test/hdi/v1_1/BUILD.gn +++ b/camera/test/hdi/v1_1/BUILD.gn @@ -16,7 +16,6 @@ camera_test_path = "//drivers/peripheral/camera/test/hdi/" import("//build/ohos.gni") import("//build/test.gni") -import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -51,18 +50,15 @@ ohos_unittest("camera_test_hdi_V1_1") { include_dirs = [ # common includes "$camera_test_path/v1_1/include", - "//third_party/googletest/googletest/include", - "$camera_path/../../../display/interfaces/include", - "$camera_path/../../../display/hdi_service/gralloc/include", "$camera_path/../../interfaces/include", "$camera_path/include", ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest", - "//third_party/googletest:gtest_main", - ] + # deps = [ + # "//third_party/googletest:gmock_main", + # "//third_party/googletest:gtest", + # "//third_party/googletest:gtest_main", + # ] if (is_standard_system) { external_deps = [ diff --git a/camera/test/hdi/v1_2/BUILD.gn b/camera/test/hdi/v1_2/BUILD.gn index d0d11fad22..71546f812d 100644 --- a/camera/test/hdi/v1_2/BUILD.gn +++ b/camera/test/hdi/v1_2/BUILD.gn @@ -16,7 +16,6 @@ camera_test_path = "//drivers/peripheral/camera/test/hdi/" import("//build/ohos.gni") import("//build/test.gni") -import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" diff --git a/camera/test/ut/buffer_manager/BUILD.gn b/camera/test/ut/buffer_manager/BUILD.gn index 575344eae2..384356c068 100644 --- a/camera/test/ut/buffer_manager/BUILD.gn +++ b/camera/test/ut/buffer_manager/BUILD.gn @@ -48,7 +48,6 @@ if (defined(ohos_lite)) { # buffer manager includes "$camera_path/buffer_manager/include", "$camera_path/buffer_manager/src/buffer_adapter/lite", - "//third_party/googletest/googletest/include", "$camera_path/../../base", "$camera_path/../../display/interfaces/include", @@ -84,7 +83,6 @@ if (defined(ohos_lite)) { } } else { import("//build/test.gni") - import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -107,11 +105,6 @@ if (defined(ohos_lite)) { ] include_dirs = [ - # common includes - "//third_party/googletest/googletest/include", - "$camera_path/../../display/interfaces/include", - "$camera_path/../../display/hdi_service/gralloc/include", - # camera common includes "$camera_path/include", "$camera_path/../../interfaces/include", @@ -163,9 +156,9 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/../../hdi_service/v1_0:camera_host_service_1.0_static", "$camera_path/buffer_manager:peripheral_camera_buffer_manager", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest", - "//third_party/googletest:gtest_main", + # "//third_party/googletest:gmock_main", + # "//third_party/googletest:gtest", + # "//third_party/googletest:gtest_main", ] if (is_standard_system) { diff --git a/camera/test/ut/usb_camera/BUILD.gn b/camera/test/ut/usb_camera/BUILD.gn index d9cb730db5..5e1cb64d75 100644 --- a/camera/test/ut/usb_camera/BUILD.gn +++ b/camera/test/ut/usb_camera/BUILD.gn @@ -14,7 +14,6 @@ import("../../../vdi_base/usb_camera/camera_usb.gni") import("//build/test.gni") -import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -36,11 +35,6 @@ ohos_unittest("camera_usb_test_ut") { ] include_dirs = [ - # common includes - "$third_path/googletest/googletest/include", - "$camera_path_usb/../../../display/interfaces/include", - "$camera_path_usb/../../../display/hdi_service/gralloc/include", - # camera common includes "$camera_path_vdi/include", "$camera_path_usb/../../interfaces/include", @@ -98,9 +92,9 @@ ohos_unittest("camera_usb_test_ut") { "$camera_path_usb/device_manager:usb_camera_device_manager", "$camera_path_usb/pipeline_core:usb_camera_pipeline_core", "$camera_path_usb/vdi_impl:camera_daemon_static", - "$third_path/googletest:gmock_main", - "$third_path/googletest:gtest", - "$third_path/googletest:gtest_main", + # "$third_path/googletest:gmock_main", + # "$third_path/googletest:gtest", + # "$third_path/googletest:gtest_main", ] external_deps = [ diff --git a/camera/test/ut/v4l2/BUILD.gn b/camera/test/ut/v4l2/BUILD.gn index 0f3cf8b8b5..3672e1fd58 100644 --- a/camera/test/ut/v4l2/BUILD.gn +++ b/camera/test/ut/v4l2/BUILD.gn @@ -48,7 +48,6 @@ if (defined(ohos_lite)) { # buffer manager includes "$camera_path/buffer_manager/include", "$camera_path/buffer_manager/src/buffer_adapter/lite", - "//third_party/googletest/googletest/include", "$camera_path/../../base", "$camera_path/../../display/interfaces/include", @@ -84,7 +83,6 @@ if (defined(ohos_lite)) { } } else { import("//build/test.gni") - import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") module_output_path = "drivers_peripheral_camera/camera" @@ -122,11 +120,6 @@ if (defined(ohos_lite)) { ] include_dirs = [ - # common includes - "//third_party/googletest/googletest/include", - "$camera_path/../../display/interfaces/include", - "$camera_path/../../display/hdi_service/gralloc/include", - # camera common includes "$camera_path/include", "$camera_path/../../interfaces/include", @@ -178,9 +171,9 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/../../hdi_service/v1_0:camera_host_service_1.0_static", "$camera_path/buffer_manager:peripheral_camera_buffer_manager", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest", - "//third_party/googletest:gtest_main", + # "//third_party/googletest:gmock_main", + # "//third_party/googletest:gtest", + # "//third_party/googletest:gtest_main", ] if (is_standard_system) { diff --git a/camera/vdi_base/common/adapter/platform/v4l2/src/driver_adapter/BUILD.gn b/camera/vdi_base/common/adapter/platform/v4l2/src/driver_adapter/BUILD.gn index a3b427d742..73e9c87f56 100644 --- a/camera/vdi_base/common/adapter/platform/v4l2/src/driver_adapter/BUILD.gn +++ b/camera/vdi_base/common/adapter/platform/v4l2/src/driver_adapter/BUILD.gn @@ -12,7 +12,6 @@ # limitations under the License. import("//build/ohos.gni") -import("../../../../../../../../../hdf_core/adapter/uhdf2/uhdf.gni") import("../../../../../../../camera.gni") config("v4l2_config") { diff --git a/camera/vdi_base/common/metadata_manager/BUILD.gn b/camera/vdi_base/common/metadata_manager/BUILD.gn index 000f1ce737..84faaeb2c6 100644 --- a/camera/vdi_base/common/metadata_manager/BUILD.gn +++ b/camera/vdi_base/common/metadata_manager/BUILD.gn @@ -15,7 +15,6 @@ import("../../../camera.gni") if (!defined(ohos_lite)) { import("//build/ohos.gni") - import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") config("camera_metadata_manager_config") { visibility = [ ":*" ] diff --git a/camera/vdi_base/common/pipeline_core/BUILD.gn b/camera/vdi_base/common/pipeline_core/BUILD.gn index dce841e59f..6c88eeee9d 100644 --- a/camera/vdi_base/common/pipeline_core/BUILD.gn +++ b/camera/vdi_base/common/pipeline_core/BUILD.gn @@ -16,7 +16,6 @@ import("//build/ohos.gni") import("../../../camera.gni") # NOSORT -import("$hdf_core_path/adapter/uhdf2/uhdf.gni") config("pipe_config") { visibility = [ ":*" ] diff --git a/camera/vdi_base/usb_camera/BUILD.gn b/camera/vdi_base/usb_camera/BUILD.gn index f81b1cd846..f9da141681 100644 --- a/camera/vdi_base/usb_camera/BUILD.gn +++ b/camera/vdi_base/usb_camera/BUILD.gn @@ -11,8 +11,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("../../../../hdf_core/adapter/uhdf2/uhdf.gni") - group("usb_camera_vdi_impl") { deps = [ "buffer_manager:usb_camera_buffer_manager", diff --git a/camera/vdi_base/usb_camera/adapter/platform/v4l2/src/driver_adapter/BUILD.gn b/camera/vdi_base/usb_camera/adapter/platform/v4l2/src/driver_adapter/BUILD.gn index f3a96f12f2..25010bc91e 100644 --- a/camera/vdi_base/usb_camera/adapter/platform/v4l2/src/driver_adapter/BUILD.gn +++ b/camera/vdi_base/usb_camera/adapter/platform/v4l2/src/driver_adapter/BUILD.gn @@ -17,7 +17,6 @@ import("//build/ohos.gni") import("../../../../../../../camera.gni") # NOSORT -import("$hdf_core_path/adapter/uhdf2/uhdf.gni") import("../../../../../camera_usb.gni") config("v4l2_config") { visibility = [ ":*" ] diff --git a/camera/vdi_base/usb_camera/camera_config/BUILD.gn b/camera/vdi_base/usb_camera/camera_config/BUILD.gn index 089d32d5b2..7079bc9562 100644 --- a/camera/vdi_base/usb_camera/camera_config/BUILD.gn +++ b/camera/vdi_base/usb_camera/camera_config/BUILD.gn @@ -16,8 +16,6 @@ import("//build/ohos.gni") import("../../../camera.gni") # NOSORT -import("$hdf_core_path/adapter/uhdf2/uhdf.gni") -import("$hdf_framework_path/tools/hc-gen/hc_gen.gni") import("../camera_usb.gni") hc_gen_c("generate_source") { sources = [ diff --git a/camera/vdi_base/usb_camera/metadata_manager/BUILD.gn b/camera/vdi_base/usb_camera/metadata_manager/BUILD.gn index 1a40fd69dd..35e4c1da6c 100644 --- a/camera/vdi_base/usb_camera/metadata_manager/BUILD.gn +++ b/camera/vdi_base/usb_camera/metadata_manager/BUILD.gn @@ -16,7 +16,6 @@ import("../camera_usb.gni") if (!defined(ohos_lite)) { import("//build/ohos.gni") - import("../../../../../hdf_core/adapter/uhdf2/uhdf.gni") config("usb_camera_metadata_manager_config") { visibility = [ ":*" ] diff --git a/camera/vdi_base/usb_camera/pipeline_core/BUILD.gn b/camera/vdi_base/usb_camera/pipeline_core/BUILD.gn index 95b9e4d587..e504937e15 100644 --- a/camera/vdi_base/usb_camera/pipeline_core/BUILD.gn +++ b/camera/vdi_base/usb_camera/pipeline_core/BUILD.gn @@ -16,7 +16,6 @@ import("//build/ohos.gni") import("../../../camera.gni") # NOSORT -import("$hdf_core_path/adapter/uhdf2/uhdf.gni") import("../camera_usb.gni") config("pipe_config") { visibility = [ ":*" ] diff --git a/camera/vdi_base/usb_camera/vdi_impl/BUILD.gn b/camera/vdi_base/usb_camera/vdi_impl/BUILD.gn index a344b2971d..afea5554f9 100644 --- a/camera/vdi_base/usb_camera/vdi_impl/BUILD.gn +++ b/camera/vdi_base/usb_camera/vdi_impl/BUILD.gn @@ -17,7 +17,6 @@ import("//build/ohos.gni") import("../../../camera.gni") # NOSORT -import("$hdf_core_path/adapter/uhdf2/uhdf.gni") import("../camera_usb.gni") config("camhdi_impl_config") { visibility = [ ":*" ] -- Gitee From 4946b2ec858774f1018fda156f022517155524b7 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Mon, 19 Aug 2024 09:08:03 +0800 Subject: [PATCH 0247/1485] code review Signed-off-by: hechaofan --- usb/gadget/function/ecm/cdcecm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/gadget/function/ecm/cdcecm.c b/usb/gadget/function/ecm/cdcecm.c index 170457c4ba..a1a0c0c3a0 100644 --- a/usb/gadget/function/ecm/cdcecm.c +++ b/usb/gadget/function/ecm/cdcecm.c @@ -1028,7 +1028,7 @@ static void EcmDriverRelease(struct HdfDeviceObject *device) UsbEcmFree(ecm); (void)OsalMutexDestroy(&ecm->lock); OsalMemFree(ecm); - ecm = NULL; + device->service = NULL; } struct HdfDriverEntry g_ecmDriverEntry = { -- Gitee From 331bcdd747b205b7abefe612cc70d0d066ebfe7f Mon Sep 17 00:00:00 2001 From: cwx1272435 Date: Mon, 19 Aug 2024 03:04:06 +0000 Subject: [PATCH 0248/1485] 0819 Signed-off-by: cwx1272435 --- memorytracker/hdi_service/BUILD.gn | 1 - memorytracker/test/BUILD.gn | 3 --- 2 files changed, 4 deletions(-) diff --git a/memorytracker/hdi_service/BUILD.gn b/memorytracker/hdi_service/BUILD.gn index 061077efb7..09cdda15b7 100644 --- a/memorytracker/hdi_service/BUILD.gn +++ b/memorytracker/hdi_service/BUILD.gn @@ -12,7 +12,6 @@ # limitations under the License. import("//build/ohos.gni") -import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") ohos_shared_library("libmemory_tracker_interface_service_1.0") { visibility = [ ":*" ] diff --git a/memorytracker/test/BUILD.gn b/memorytracker/test/BUILD.gn index abdae63882..3c5e66e497 100644 --- a/memorytracker/test/BUILD.gn +++ b/memorytracker/test/BUILD.gn @@ -24,14 +24,11 @@ memorytracker_external_deps = [ "ipc:ipc_core", ] -memmgr_public_deps = [ "//third_party/googletest:gtest_main" ] - ohos_unittest("memorytracker_test") { module_out_path = module_output_path sources = [ "unittest/phone/hdf_memorytracker_test.cpp" ] if (is_standard_system) { external_deps = memorytracker_external_deps - public_deps = memmgr_public_deps } } group("memorytracker_unittest") { -- Gitee From de1538fc6aa2d4334aaff8a661420909f36f41e2 Mon Sep 17 00:00:00 2001 From: shilong Date: Mon, 19 Aug 2024 08:34:37 +0000 Subject: [PATCH 0249/1485] =?UTF-8?q?Delete=EF=BC=9A=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E9=94=81=EF=BC=8C=E5=AF=BC=E8=87=B4signal=2011?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/include/input_device_manager.h | 1 - input/udriver/src/input_device_manager.cpp | 6 ------ 2 files changed, 7 deletions(-) diff --git a/input/udriver/include/input_device_manager.h b/input/udriver/include/input_device_manager.h index 3290ed4b68..53bb54c50f 100644 --- a/input/udriver/include/input_device_manager.h +++ b/input/udriver/include/input_device_manager.h @@ -136,7 +136,6 @@ private: int32_t &epollFd, int32_t &fd, string devPath, std::shared_ptr &detailInfo); mutable std::mutex lock_; - std::mutex reportEventPkgCallBackLock_; std::map inputDevList_; struct epoll_event epollEventList_[EPOLL_MAX_EVENTS] {}; std::string devPath_ {"/dev/input"}; diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index b071443dbd..515a228ab8 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -44,9 +44,7 @@ constexpr uint32_t DEV_INDEX_MAX = 32; void InputDeviceManager::Init() { inputDevList_.clear(); - reportEventPkgCallBackLock_.lock(); reportEventPkgCallback_.clear(); - reportEventPkgCallBackLock_.unlock(); GetInputDeviceInfoList(); std::thread t1([this] {this->WorkerThread();}); std::string wholeName1 = std::to_string(getpid()) + "_" + std::to_string(gettid()); @@ -102,8 +100,6 @@ void InputDeviceManager::ReportEventPkg(int32_t iFd, InputEventPackage **iEvtPkg HDF_LOGE("%{public}s: param invalid, line: %{public}d", __func__, __LINE__); return; } - - std::lock_guard guard(reportEventPkgCallBackLock_); for (auto &callbackFunc : reportEventPkgCallback_) { uint32_t index {0}; auto ret = FindIndexFromFd(iFd, &index); @@ -828,7 +824,6 @@ RetStatus InputDeviceManager::RegisterReportCallback(uint32_t devIndex, InputEve HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } - std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = callback; return rc; } @@ -841,7 +836,6 @@ RetStatus InputDeviceManager::UnregisterReportCallback(uint32_t devIndex) HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } - std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = nullptr; return rc; } -- Gitee From 340b6e1d3e50b3f961914d60f2246cd38b056779 Mon Sep 17 00:00:00 2001 From: liufeng Date: Mon, 19 Aug 2024 17:12:42 +0800 Subject: [PATCH 0250/1485] =?UTF-8?q?=E8=8A=AF=E7=89=87=E7=BB=84=E4=BB=B6?= =?UTF-8?q?=E7=8B=AC=E7=AB=8B=E6=9E=84=E5=BB=BA=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/test/hdi/metadata_test/BUILD.gn | 6 +----- camera/test/hdi/v1_0/BUILD.gn | 6 +----- camera/test/hdi/v1_1/BUILD.gn | 6 +----- camera/test/ut/buffer_manager/BUILD.gn | 3 --- camera/test/ut/usb_camera/BUILD.gn | 3 --- camera/test/ut/v4l2/BUILD.gn | 3 --- 6 files changed, 3 insertions(+), 24 deletions(-) diff --git a/camera/test/hdi/metadata_test/BUILD.gn b/camera/test/hdi/metadata_test/BUILD.gn index d027645298..ba1820aa52 100644 --- a/camera/test/hdi/metadata_test/BUILD.gn +++ b/camera/test/hdi/metadata_test/BUILD.gn @@ -48,11 +48,7 @@ ohos_unittest("camera_metadata_operator_ut") { "$camera_path/include", ] - # deps = [ - # "//third_party/googletest:gmock_main", - # "//third_party/googletest:gtest", - # "//third_party/googletest:gtest_main", - # ] + deps = [] if (is_standard_system) { external_deps = [ diff --git a/camera/test/hdi/v1_0/BUILD.gn b/camera/test/hdi/v1_0/BUILD.gn index a8f2bbef50..b3f97e90e8 100644 --- a/camera/test/hdi/v1_0/BUILD.gn +++ b/camera/test/hdi/v1_0/BUILD.gn @@ -120,11 +120,7 @@ if (defined(ohos_lite)) { "$camera_path/include", ] - # deps = [ - # "//third_party/googletest:gmock_main", - # "//third_party/googletest:gtest", - # "//third_party/googletest:gtest_main", - # ] + deps = [] if (is_standard_system) { external_deps = [ diff --git a/camera/test/hdi/v1_1/BUILD.gn b/camera/test/hdi/v1_1/BUILD.gn index 0a85d6cc07..2592cf149b 100644 --- a/camera/test/hdi/v1_1/BUILD.gn +++ b/camera/test/hdi/v1_1/BUILD.gn @@ -54,11 +54,7 @@ ohos_unittest("camera_test_hdi_V1_1") { "$camera_path/include", ] - # deps = [ - # "//third_party/googletest:gmock_main", - # "//third_party/googletest:gtest", - # "//third_party/googletest:gtest_main", - # ] + deps = [] if (is_standard_system) { external_deps = [ diff --git a/camera/test/ut/buffer_manager/BUILD.gn b/camera/test/ut/buffer_manager/BUILD.gn index 384356c068..deb50b5a7c 100644 --- a/camera/test/ut/buffer_manager/BUILD.gn +++ b/camera/test/ut/buffer_manager/BUILD.gn @@ -156,9 +156,6 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/../../hdi_service/v1_0:camera_host_service_1.0_static", "$camera_path/buffer_manager:peripheral_camera_buffer_manager", - # "//third_party/googletest:gmock_main", - # "//third_party/googletest:gtest", - # "//third_party/googletest:gtest_main", ] if (is_standard_system) { diff --git a/camera/test/ut/usb_camera/BUILD.gn b/camera/test/ut/usb_camera/BUILD.gn index 5e1cb64d75..872b8d3388 100644 --- a/camera/test/ut/usb_camera/BUILD.gn +++ b/camera/test/ut/usb_camera/BUILD.gn @@ -92,9 +92,6 @@ ohos_unittest("camera_usb_test_ut") { "$camera_path_usb/device_manager:usb_camera_device_manager", "$camera_path_usb/pipeline_core:usb_camera_pipeline_core", "$camera_path_usb/vdi_impl:camera_daemon_static", - # "$third_path/googletest:gmock_main", - # "$third_path/googletest:gtest", - # "$third_path/googletest:gtest_main", ] external_deps = [ diff --git a/camera/test/ut/v4l2/BUILD.gn b/camera/test/ut/v4l2/BUILD.gn index 3672e1fd58..eef3846882 100644 --- a/camera/test/ut/v4l2/BUILD.gn +++ b/camera/test/ut/v4l2/BUILD.gn @@ -171,9 +171,6 @@ if (defined(ohos_lite)) { deps = [ "$camera_path/../../hdi_service/v1_0:camera_host_service_1.0_static", "$camera_path/buffer_manager:peripheral_camera_buffer_manager", - # "//third_party/googletest:gmock_main", - # "//third_party/googletest:gtest", - # "//third_party/googletest:gtest_main", ] if (is_standard_system) { -- Gitee From b76b6374ddbf53f767294a76556ed081a4995f81 Mon Sep 17 00:00:00 2001 From: zhanghang133 Date: Mon, 19 Aug 2024 19:53:19 +0800 Subject: [PATCH 0251/1485] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhanghang133 --- camera/test/hdi/v1_3/BUILD.gn | 1 + .../v1_3/include/camera_hdi_tag_test_v1_3.h | 31 +++++ .../hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp | 113 ++++++++++++++++++ .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 44 +++++++ 4 files changed, 189 insertions(+) create mode 100644 camera/test/hdi/v1_3/include/camera_hdi_tag_test_v1_3.h create mode 100644 camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp diff --git a/camera/test/hdi/v1_3/BUILD.gn b/camera/test/hdi/v1_3/BUILD.gn index 7ecb02a1e2..c6d769934c 100644 --- a/camera/test/hdi/v1_3/BUILD.gn +++ b/camera/test/hdi/v1_3/BUILD.gn @@ -35,6 +35,7 @@ ohos_unittest("camera_test_hdi_V1_3") { module_out_path = module_output_path sources = [ "$camera_test_path/v1_3/src/camera_front_uttest_v1_3.cpp", + "$camera_test_path/v1_3/src/camera_hdi_tag_test_v1_3.cpp", "$camera_test_path/v1_3/src/camera_hdi_uttest_securestream_v1_3.cpp", "$camera_test_path/v1_3/src/camera_hdi_uttest_v1_3.cpp", "$camera_test_path/v1_3/src/camera_professional_uttest_v1_3.cpp", diff --git a/camera/test/hdi/v1_3/include/camera_hdi_tag_test_v1_3.h b/camera/test/hdi/v1_3/include/camera_hdi_tag_test_v1_3.h new file mode 100644 index 0000000000..17e4aca2c6 --- /dev/null +++ b/camera/test/hdi/v1_3/include/camera_hdi_tag_test_v1_3.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file expected in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CAMERA_HDI_TAG_TEST_V1_3_H +#define CAMERA_HDI_TAG_TEST_V1_3_H + +#include "hdi_common_v1_3.h" + +class CameraHdiTagTestV1_3 : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + bool IsTagValueExistsU8(std::shared_ptr ability, uint32_t tag, uint8_t value); + void PrintAllTagDataU8(std::shared_ptr ability, uint32_t tag); + std::shared_ptr cameraTest = nullptr; +}; +#endif diff --git a/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp new file mode 100644 index 0000000000..198b6b5d7d --- /dev/null +++ b/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file expected in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "camera_hdi_tag_test_v1_3.h" +#include + +using namespace OHOS; +using namespace std; +using namespace testing::ext; +using namespace OHOS::Camera; + +void CameraHdiTagTestV1_3::SetUpTestCase(void) {} +void CameraHdiTagTestV1_3::TearDownTestCase(void) {} +void CameraHdiTagTestV1_3::SetUp(void) +{ + cameraTest = std::make_shared(); + cameraTest->Init(); // assert inside + cameraTest->Open(DEVICE_0); // assert inside +} + +void CameraHdiTagTestV1_3::TearDown(void) +{ + cameraTest->Close(); +} + +bool CameraHdiTagTestV1_3::IsTagValueExistsU8( + std::shared_ptr ability, uint32_t tag, uint8_t value) +{ + common_metadata_header_t* data = ability->get(); + camera_metadata_item_t entry; + int ret = FindCameraMetadataItem(data, tag, &entry); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + for (int i = 0; i < entry.count; i++) { + if (entry.data.u8[i] == value) { + return true; + } + } + } + return false; +} + +void CameraHdiTagTestV1_3::PrintAllTagDataU8(std::shared_ptr ability, uint32_t tag) +{ + common_metadata_header_t* data = ability->get(); + camera_metadata_item_t entry; + int ret = FindCameraMetadataItem(data, tag, &entry); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) { + cout << "----tag = " << tag << "count = " << entry.count << endl; + for (int i = 0; i < entry.count; i++) { + int v = entry.data.u8[i]; + cout << "tag[" << tag << "][" << i << "] = " << v << endl; + } + cout << "--------------------------------" << endl; + } +} + +/** + * @tc.name: Camera_Hdi_TAG_TEST_V1_3_001 + * @tc.desc: report camera support detect type OHOS_ABILITY_STATISTICS_DETECT_TYPE + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiTagTestV1_3, Camera_Hdi_TAG_TEST_V1_3_001, TestSize.Level1) +{ + CAMERA_LOGI("CameraHdiTagTestV1_3 Camera_Hdi_TAG_TEST_V1_3_001 start ..."); + EXPECT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + EXPECT_NE(data, nullptr); + PrintAllTagDataU8(cameraTest->ability, OHOS_ABILITY_STATISTICS_DETECT_TYPE); +} + +/** + * @tc.name: Camera_Hdi_TAG_TEST_V1_3_002 + * @tc.desc: report camera support tripod detect OHOS_ABILITY_TRIPOD_DETECTION + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiTagTestV1_3, Camera_Hdi_TAG_TEST_V1_3_002, TestSize.Level1) +{ + CAMERA_LOGI("CameraHdiTagTestV1_3 Camera_Hdi_TAG_TEST_V1_3_002 start ..."); + EXPECT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + EXPECT_NE(data, nullptr); + camera_metadata_item_t entry; + int ret = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry); + if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + constexpr size_t step = 10; + std::stringstream ss; + for (size_t i = 0; i < entry.count; i++) { + ss << entry.data.i32[i] << " "; + if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { + CAMERA_LOGI("OHOS_ABILITY_TRIPOD_DETECTION %{public}s\n", ss.str().c_str()); + printf("OHOS_ABILITY_TRIPOD_DETECTION %s\n", ss.str().c_str()); + ss.clear(); + ss.str(""); + } + } + } else { + CAMERA_LOGI("Camera_Hdi_TAG_TEST_V1_3_002 not support OHOS_ABILITY_TRIPOD_DETECTION"); + printf("Camera_Hdi_TAG_TEST_V1_3_002 not support OHOS_ABILITY_TRIPOD_DETECTION\n"); + } +} \ No newline at end of file diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 08baf64b38..c61baf9db1 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -1938,4 +1938,48 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_047, TestSize.Level1) cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo}; cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo}; cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); +} + +/** + * @tc.name: Camera_Device_Hdi_V1_3_048 + * @tc.desc: OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, OHOS_CONTROL_ZOOM_RATIO, PROFESSIONAL_PHOTO + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_048, TestSize.Level1) +{ + // 查询是否支持脚架检测 + EXPECT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + EXPECT_NE(data, nullptr); + camera_metadata_item_t entry; + cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (*entry.data.i32 == 1) { + cameraTest->imageDataSaveSwitch = SWITCH_ON; + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + // 修改Zoom大于15x + float zoomRatio = 15.0f; + meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT); + // 使能脚架检测 + uint8_t tripoDetection = 1; + meta->addEntry(OHOS_CONTROL_TRIPOD_DETECTION, &tripoDetection, DATA_COUNT); + // 使能脚架检测算法 + uint8_t tripodStablitationAlgorithm = 1; + meta->addEntry(OHOS_CONTROL_TRIPOD_STABLITATION, &tripodStablitationAlgorithm, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + sleep(3); + // 进行拍照 + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } } \ No newline at end of file -- Gitee From 437987ff56c1d615645254afd6946c507eea382f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Mon, 19 Aug 2024 13:57:43 +0000 Subject: [PATCH 0252/1485] update camera/vdi_base/usb_camera/camera_config/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/vdi_base/usb_camera/camera_config/BUILD.gn | 2 ++ 1 file changed, 2 insertions(+) diff --git a/camera/vdi_base/usb_camera/camera_config/BUILD.gn b/camera/vdi_base/usb_camera/camera_config/BUILD.gn index 7079bc9562..362fbbba43 100644 --- a/camera/vdi_base/usb_camera/camera_config/BUILD.gn +++ b/camera/vdi_base/usb_camera/camera_config/BUILD.gn @@ -16,6 +16,8 @@ import("//build/ohos.gni") import("../../../camera.gni") # NOSORT +import("//build/config/components/hdi/hdi.gni") +import("$hdf_fwk_path/tools/hc-gen/hc_gen.gni") import("../camera_usb.gni") hc_gen_c("generate_source") { sources = [ -- Gitee From 64310f9daab2dff8c1f962683d832678d86d60f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Tue, 20 Aug 2024 01:55:45 +0000 Subject: [PATCH 0253/1485] update display/composer/test/unittest/hdi_composer_ut.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- display/composer/test/unittest/hdi_composer_ut.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/display/composer/test/unittest/hdi_composer_ut.cpp b/display/composer/test/unittest/hdi_composer_ut.cpp index a314b8c349..5846fd667f 100644 --- a/display/composer/test/unittest/hdi_composer_ut.cpp +++ b/display/composer/test/unittest/hdi_composer_ut.cpp @@ -18,7 +18,7 @@ #include #include #include "v1_2/include/idisplay_composer_interface.h" -#include "v1_1/display_composer_type.h" +#include "v1_2/display_composer_type.h" #include "v1_0/display_buffer_type.h" #include "display_test.h" #include "display_test_utils.h" -- Gitee From 7fed46725d0f14222c412c34f15ed83f60322c7c Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 11:27:46 +0800 Subject: [PATCH 0254/1485] =?UTF-8?q?wpa=5Fhost=20crash=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/wpa_p2p_hal.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 52a4289b51..624a34c144 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -624,9 +624,10 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceDel(WifiWpaP2pInterface *this, co if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - unsigned nameLen = strlen((char *) argv->name); - unsigned queryLen = strlen((char *) argv->query); - if ((argv->mode == 0 && nameLen == 0) || (argv->mode == 1 && queryLen == 0)) { + unsigned nameLen = 0; + unsigned queryLen = 0; + if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name))== 0)) || + (argv->mode != 0 && (argv->query == NULL || (queryLen = strlen((char *) argv->query))== 0))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; -- Gitee From 42cc2ada2e31e85b98a5f5356f8b945935245eb4 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 03:53:59 +0000 Subject: [PATCH 0255/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/wpa_p2p_hal.c | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 624a34c144..da0ffa8d48 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -89,7 +89,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdWpsPbc(WifiWpaP2pGroupInterface *this, c static P2pSupplicantErrCode WpaP2pCliCmdWpsPin(WifiWpaP2pGroupInterface *this, P2pWpsPinDisplayArgv *argv) { - if (this == NULL || argv == NULL) { + if (this == NULL || argv == NULL || argv->pinCode) { return P2P_SUP_ERRCODE_INVALID; } if ((argv->mode != P2P_PIN_KEYPAD && argv->mode != P2P_PIN_DISPLAY) || @@ -434,7 +434,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdSetWfdEnable(WifiWpaP2pInterface *this, static P2pSupplicantErrCode WpaP2pCliCmdSetWfdDeviceInfo(WifiWpaP2pInterface *this, const char *conf) { - if (this == NULL || conf == NULL) { + if (this == NULL || conf == NULL || this->ifName) { return P2P_SUP_ERRCODE_INVALID; } unsigned len = strlen(conf); @@ -532,7 +532,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdCancelConnect(WifiWpaP2pInterface *this) static P2pSupplicantErrCode WpaP2pCliCmdInvite(WifiWpaP2pInterface *this, const P2pHalInviteArgv *argv) { - if (this == NULL || argv == NULL) { + if (this == NULL || argv == NULL || argv->peerbssid == NULL || argv->gobssid == NULL || argv->ifname == NULL) { return P2P_SUP_ERRCODE_INVALID; } if (strlen(argv->peerbssid) <= 0 || strlen(argv->gobssid) <= 0 || strlen(argv->ifname) <= 0) { @@ -557,7 +557,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdReInvite(WifiWpaP2pInterface *this, cons if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - if (strlen(argv->peerbssid) <= 0) { + if (argv->peerbssid == NULL || strlen(argv->peerbssid) <= 0) { return P2P_SUP_ERRCODE_INPUT_ERROR; } char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0}; @@ -579,10 +579,12 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, co if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - unsigned nameLen = strlen((char *) argv->name); - unsigned queryLen = strlen((char *) argv->query); - unsigned respLen = strlen((char *) argv->resp); - if ((argv->mode == 0 && nameLen == 0) || (argv->mode != 0 && (queryLen == 0 || respLen == 0))) { + unsigned nameLen = 0; + unsigned queryLen = 0; + unsigned respLen = 0; + if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || + (argv->mode != 0 && ((argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0) || + (argv->resp == NULL || (respLen = strlen((char *) argv->resp)) == 0)))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; @@ -722,7 +724,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdProvisionDiscovery( if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - if (strlen(argv->peerbssid) <= 0) { + if (argv->peerbssid == NULL || strlen(argv->peerbssid) <= 0) { return P2P_SUP_ERRCODE_INPUT_ERROR; } char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0}; -- Gitee From 7825e6c4454a3a102bb6ff6cf828caacb2229b0a Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 04:01:42 +0000 Subject: [PATCH 0256/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/wpa_p2p_hal.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index da0ffa8d48..1365065471 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -89,7 +89,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdWpsPbc(WifiWpaP2pGroupInterface *this, c static P2pSupplicantErrCode WpaP2pCliCmdWpsPin(WifiWpaP2pGroupInterface *this, P2pWpsPinDisplayArgv *argv) { - if (this == NULL || argv == NULL || argv->pinCode) { + if (this == NULL || argv == NULL || argv->pinCode == NULL) { return P2P_SUP_ERRCODE_INVALID; } if ((argv->mode != P2P_PIN_KEYPAD && argv->mode != P2P_PIN_DISPLAY) || @@ -434,7 +434,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdSetWfdEnable(WifiWpaP2pInterface *this, static P2pSupplicantErrCode WpaP2pCliCmdSetWfdDeviceInfo(WifiWpaP2pInterface *this, const char *conf) { - if (this == NULL || conf == NULL || this->ifName) { + if (this == NULL || conf == NULL || this->ifName == NULL) { return P2P_SUP_ERRCODE_INVALID; } unsigned len = strlen(conf); @@ -532,7 +532,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdCancelConnect(WifiWpaP2pInterface *this) static P2pSupplicantErrCode WpaP2pCliCmdInvite(WifiWpaP2pInterface *this, const P2pHalInviteArgv *argv) { - if (this == NULL || argv == NULL || argv->peerbssid == NULL || argv->gobssid == NULL || argv->ifname == NULL) { + if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } if (strlen(argv->peerbssid) <= 0 || strlen(argv->gobssid) <= 0 || strlen(argv->ifname) <= 0) { @@ -557,7 +557,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdReInvite(WifiWpaP2pInterface *this, cons if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - if (argv->peerbssid == NULL || strlen(argv->peerbssid) <= 0) { + if (strlen(argv->peerbssid) <= 0) { return P2P_SUP_ERRCODE_INPUT_ERROR; } char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0}; @@ -724,7 +724,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdProvisionDiscovery( if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } - if (argv->peerbssid == NULL || strlen(argv->peerbssid) <= 0) { + if (strlen(argv->peerbssid) <= 0) { return P2P_SUP_ERRCODE_INPUT_ERROR; } char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0}; -- Gitee From f4bf218426a11af17279a965568c29703cff345d Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 04:04:31 +0000 Subject: [PATCH 0257/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 1365065471..617471adc0 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -89,7 +89,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdWpsPbc(WifiWpaP2pGroupInterface *this, c static P2pSupplicantErrCode WpaP2pCliCmdWpsPin(WifiWpaP2pGroupInterface *this, P2pWpsPinDisplayArgv *argv) { - if (this == NULL || argv == NULL || argv->pinCode == NULL) { + if (this == NULL || argv == NULL) { return P2P_SUP_ERRCODE_INVALID; } if ((argv->mode != P2P_PIN_KEYPAD && argv->mode != P2P_PIN_DISPLAY) || @@ -434,7 +434,7 @@ static P2pSupplicantErrCode WpaP2pCliCmdSetWfdEnable(WifiWpaP2pInterface *this, static P2pSupplicantErrCode WpaP2pCliCmdSetWfdDeviceInfo(WifiWpaP2pInterface *this, const char *conf) { - if (this == NULL || conf == NULL || this->ifName == NULL) { + if (this == NULL || conf == NULL) { return P2P_SUP_ERRCODE_INVALID; } unsigned len = strlen(conf); -- Gitee From 85352ad1d6513efb747d1efaae4cd40c0438d557 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E8=87=AA=E7=84=B6?= Date: Tue, 20 Aug 2024 12:05:48 +0800 Subject: [PATCH 0258/1485] remove cmd printf MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 李自然 --- wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c index 36a3d789f5..8420442479 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c @@ -1442,7 +1442,7 @@ int32_t WpaInterfaceVendorExtProcessCmd(struct IWpaInterface *self, const char * return HDF_FAILURE; } - HDF_LOGI("%{public}s cmd %{public}s reply %{public}s !", __func__, newCmd, reply); + HDF_LOGI("%{public}s reply %{public}s !", __func__, reply); ret = atoi(reply); free(reply); return ret; -- Gitee From 979120960e87e20054bd3d12535c88b196969002 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 06:28:07 +0000 Subject: [PATCH 0259/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/wpa_p2p_hal.c | 22 ++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 617471adc0..76aca39d6e 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -582,9 +582,16 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, co unsigned nameLen = 0; unsigned queryLen = 0; unsigned respLen = 0; - if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || - (argv->mode != 0 && ((argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0) || - (argv->resp == NULL || (respLen = strlen((char *) argv->resp)) == 0)))) { + if (argv->name != NULL) { + nameLen = strlen((char *) argv->name); + } + if (argv->query != NULL) { + queryLen = strlen((char *) argv->query); + } + if (argv->resp != NULL) { + respLen = strlen((char *) argv->resp); + } + if ((argv->mode == 0 && nameLen == 0) || (argv->mode != 0 && (queryLen == 0 || respLen == 0))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; @@ -628,8 +635,13 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceDel(WifiWpaP2pInterface *this, co } unsigned nameLen = 0; unsigned queryLen = 0; - if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name))== 0)) || - (argv->mode != 0 && (argv->query == NULL || (queryLen = strlen((char *) argv->query))== 0))) { + if (argv->name != NULL) { + nameLen = strlen((char *) argv->name); + } + if (argv->query != NULL) { + queryLen = strlen((char *) argv->query); + } + if ((argv->mode == 0 && nameLen == 0) || (argv->mode == 1 && queryLen == 0)) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; -- Gitee From 1f0d370b2f73dd24397417f08b989cc4ff6e4f79 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 07:08:05 +0000 Subject: [PATCH 0260/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/wpa_p2p_hal.c | 22 +++++-------------- 1 file changed, 5 insertions(+), 17 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 76aca39d6e..262100097c 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -582,16 +582,9 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, co unsigned nameLen = 0; unsigned queryLen = 0; unsigned respLen = 0; - if (argv->name != NULL) { - nameLen = strlen((char *) argv->name); - } - if (argv->query != NULL) { - queryLen = strlen((char *) argv->query); - } - if (argv->resp != NULL) { - respLen = strlen((char *) argv->resp); - } - if ((argv->mode == 0 && nameLen == 0) || (argv->mode != 0 && (queryLen == 0 || respLen == 0))) { + if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || + (argv->mode != 0 && ((argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0) || + (argv->resp == NULL || (respLen = strlen((char *) argv->resp)) == 0)))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; @@ -635,13 +628,8 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceDel(WifiWpaP2pInterface *this, co } unsigned nameLen = 0; unsigned queryLen = 0; - if (argv->name != NULL) { - nameLen = strlen((char *) argv->name); - } - if (argv->query != NULL) { - queryLen = strlen((char *) argv->query); - } - if ((argv->mode == 0 && nameLen == 0) || (argv->mode == 1 && queryLen == 0)) { + if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || + (argv->mode != 0 && (argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; -- Gitee From 6f0d1101c9244d6bc7068dec6fca55e7f0c40f8c Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 20 Aug 2024 07:22:31 +0000 Subject: [PATCH 0261/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/wpa_p2p_hal.c | 21 ++++++++----------- 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c index 262100097c..4920566112 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_hal.c @@ -576,15 +576,13 @@ static P2pSupplicantErrCode WpaP2pCliCmdReInvite(WifiWpaP2pInterface *this, cons static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, const struct HdiP2pServiceInfo *argv) { - if (this == NULL || argv == NULL) { + if (this == NULL || argv == NULL || argv->name == NULL || argv->query == NULL || argv->resp == NULL) { return P2P_SUP_ERRCODE_INVALID; } - unsigned nameLen = 0; - unsigned queryLen = 0; - unsigned respLen = 0; - if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || - (argv->mode != 0 && ((argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0) || - (argv->resp == NULL || (respLen = strlen((char *) argv->resp)) == 0)))) { + unsigned nameLen = strlen((char *) argv->name); + unsigned queryLen = strlen((char *) argv->query); + unsigned respLen = strlen((char *) argv->resp); + if ((argv->mode == 0 && nameLen == 0) || (argv->mode != 0 && (queryLen == 0 || respLen == 0))) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; @@ -623,13 +621,12 @@ static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, co static P2pSupplicantErrCode WpaP2pCliCmdServiceDel(WifiWpaP2pInterface *this, const struct HdiP2pServiceInfo *argv) { - if (this == NULL || argv == NULL) { + if (this == NULL || argv == NULL || argv->name == NULL || argv->query == NULL) { return P2P_SUP_ERRCODE_INVALID; } - unsigned nameLen = 0; - unsigned queryLen = 0; - if ((argv->mode == 0 && (argv->name == NULL || (nameLen = strlen((char *) argv->name)) == 0)) || - (argv->mode != 0 && (argv->query == NULL || (queryLen = strlen((char *) argv->query)) == 0))) { + unsigned nameLen = strlen((char *) argv->name); + unsigned queryLen = strlen((char *) argv->query); + if ((argv->mode == 0 && nameLen == 0) || (argv->mode == 1 && queryLen == 0)) { return P2P_SUP_ERRCODE_INPUT_ERROR; } unsigned cmdLen; -- Gitee From 14f3b9db3d6e33553e6b18c0a870d961dbb0bff8 Mon Sep 17 00:00:00 2001 From: yanghang Date: Fri, 16 Aug 2024 15:21:20 +0800 Subject: [PATCH 0262/1485] fix: fuzz coverage fixed Signed-off-by: yanghang --- .../batteryhdistub_fuzz.cpp | 6 +- power/test/BUILD.gn | 1 + power/test/fuzztest/powerhdi_fuzzer/BUILD.gn | 51 ++++++++ .../test/fuzztest/powerhdi_fuzzer/corpus/init | 14 +++ .../powerhdi_fuzzer/powerhdi_fuzz.cpp | 111 ++++++++++++++++++ .../test/fuzztest/powerhdi_fuzzer/project.xml | 25 ++++ .../powerhdistub_fuzzer/powerhdistub_fuzz.cpp | 6 +- .../thermalhdistub_fuzz.cpp | 6 +- 8 files changed, 211 insertions(+), 9 deletions(-) create mode 100644 power/test/fuzztest/powerhdi_fuzzer/BUILD.gn create mode 100644 power/test/fuzztest/powerhdi_fuzzer/corpus/init create mode 100644 power/test/fuzztest/powerhdi_fuzzer/powerhdi_fuzz.cpp create mode 100644 power/test/fuzztest/powerhdi_fuzzer/project.xml diff --git a/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/batteryhdistub_fuzz.cpp b/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/batteryhdistub_fuzz.cpp index 2118cd72e3..f3a11269ae 100644 --- a/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/batteryhdistub_fuzz.cpp +++ b/battery/interfaces/hdi_service/test/fuzztest/batteryhdistub_fuzzer/batteryhdistub_fuzz.cpp @@ -49,9 +49,6 @@ static void BatteryStubFuzzTest(const uint8_t *data, size_t size) } MessageParcel datas; - datas.WriteInterfaceToken(IBatteryInterface::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(REWIND_READ_DATA); MessageParcel reply; MessageOption option; if (g_fuzzService == nullptr) { @@ -60,6 +57,9 @@ static void BatteryStubFuzzTest(const uint8_t *data, size_t size) g_fuzzService = make_shared(impl); } for (code = CMD_BATTERY_INTERFACE_GET_VERSION; code < BATTERY_INTERFACE_STUB_FUNC_MAX_SIZE; code++) { + datas.WriteInterfaceToken(IBatteryInterface::GetDescriptor()); + datas.WriteBuffer(data, size); + datas.RewindRead(REWIND_READ_DATA); g_fuzzService->OnRemoteRequest(code, datas, reply, option); } } diff --git a/power/test/BUILD.gn b/power/test/BUILD.gn index bce902b200..872f2cdfbe 100644 --- a/power/test/BUILD.gn +++ b/power/test/BUILD.gn @@ -17,6 +17,7 @@ import("//build/test.gni") group("hdf_test_power") { testonly = true deps = [ + "fuzztest/powerhdi_fuzzer:hdf_power_hdi_fuzztest", "fuzztest/powerhdistub_fuzzer:hdf_power_stub_fuzztest", "unittest:hdi_unittest_power", "unittest:hdi_unittest_power_runninglock", diff --git a/power/test/fuzztest/powerhdi_fuzzer/BUILD.gn b/power/test/fuzztest/powerhdi_fuzzer/BUILD.gn new file mode 100644 index 0000000000..99ee913602 --- /dev/null +++ b/power/test/fuzztest/powerhdi_fuzzer/BUILD.gn @@ -0,0 +1,51 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../power.gni") + +ohos_fuzztest("PowerHdiFuzzTest") { + module_out_path = "drivers_peripheral_power/drivers_peripheral_power" + fuzz_config_file = "." + include_dirs = [ + "../../../interfaces/hdi_service/src", + "../../../utils/include", + ] + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "powerhdi_fuzz.cpp" ] + deps = [ "../../../interfaces/hdi_service:libpower_interface_service_1.2" ] + external_deps = [ + "c_utils:utils", + "drivers_interface_power:libpower_stub_1.2", + "hdf_core:libhdf_utils", + "hdf_core:libhdi", + "hilog:libhilog", + "ipc:ipc_single", + ] + if (has_power_c_utils_part) { + external_deps += [ "c_utils:utils" ] + } + subsystem_name = "hdf" + part_name = "drivers_peripheral_power" +} + +group("hdf_power_hdi_fuzztest") { + testonly = true + deps = [ ":PowerHdiFuzzTest" ] +} diff --git a/power/test/fuzztest/powerhdi_fuzzer/corpus/init b/power/test/fuzztest/powerhdi_fuzzer/corpus/init new file mode 100644 index 0000000000..4527a4fa5c --- /dev/null +++ b/power/test/fuzztest/powerhdi_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ diff --git a/power/test/fuzztest/powerhdi_fuzzer/powerhdi_fuzz.cpp b/power/test/fuzztest/powerhdi_fuzzer/powerhdi_fuzz.cpp new file mode 100644 index 0000000000..6ac10919ac --- /dev/null +++ b/power/test/fuzztest/powerhdi_fuzzer/powerhdi_fuzz.cpp @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "securec.h" +#include +#include +#include + +#include "power_interface_impl.h" +#include "v1_2/ipower_interface.h" +#include "v1_2/power_interface_stub.h" +#include "running_lock_impl.h" +#include "refbase.h" + +using namespace OHOS::HDI; +using namespace OHOS::HDI::Power::V1_2; +using namespace std; + +namespace OHOS { +namespace HDI { +namespace Power { +namespace V1_2 { +constexpr int32_t DEFAULT_TIMEOUT_FOR_TEST_MS = 100; + +class PowerFuzzTest { +public: + PowerFuzzTest() + { + impl_ = sptr::MakeSptr(); + impl_->SuspendBlock("PowerStubFuzzTest"); // Prevent device sleep + } + ~PowerFuzzTest() + { + impl_->SuspendUnblock("PowerStubFuzzTest"); + } + sptr GetImpl() const + { + return impl_; + } + +private: + sptr impl_ = nullptr; +}; +namespace { +shared_ptr g_fuzzService = nullptr; +shared_ptr g_fuzzTest = nullptr; +const uint32_t POWER_INTERFACE_STUB_FUNC_MAX_SIZE = 18; +} // namespace + +static void PowerHdiFuzzTest(const uint8_t *data, size_t size) +{ + uint32_t code; + if (size < sizeof(code)) { + return; + } + if (memcpy_s(&code, sizeof(code), data, sizeof(code)) != EOK) { + return; + } + OHOS::HDI::Power::V1_2::IPowerInterface::Get(true); + + MessageParcel datas; + MessageParcel reply; + MessageOption option; + if (g_fuzzService == nullptr) { + g_fuzzTest = make_shared(); + g_fuzzService = make_shared(g_fuzzTest->GetImpl()); + } + for (code = CMD_POWER_INTERFACE_GET_VERSION; code < POWER_INTERFACE_STUB_FUNC_MAX_SIZE; code++) { + g_fuzzService->OnRemoteRequest(code, datas, reply, option); + } + RunningLockImpl::SetDefaultTimeOutMs(DEFAULT_TIMEOUT_FOR_TEST_MS); + RunningLockImpl::GetCount(RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION); + RunningLockImpl::GetRunningLockTag(RunningLockType::RUNNINGLOCK_BUTT); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BACKGROUND_TASK); + RunningLockImpl::GetRunningLockTagInner(RunningLockType::RUNNINGLOCK_BUTT); + RunningLockImpl::Clean(); +} +} // namespace V1_2 +} // namespace Power +} // namespace HDI +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + /* Run your code on data */ + OHOS::HDI::Power::V1_2::PowerHdiFuzzTest(data, size); + return 0; +} diff --git a/power/test/fuzztest/powerhdi_fuzzer/project.xml b/power/test/fuzztest/powerhdi_fuzzer/project.xml new file mode 100644 index 0000000000..39bfaaa826 --- /dev/null +++ b/power/test/fuzztest/powerhdi_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 30 + + 2048 + + diff --git a/power/test/fuzztest/powerhdistub_fuzzer/powerhdistub_fuzz.cpp b/power/test/fuzztest/powerhdistub_fuzzer/powerhdistub_fuzz.cpp index a2fa58f6c8..9483695041 100644 --- a/power/test/fuzztest/powerhdistub_fuzzer/powerhdistub_fuzz.cpp +++ b/power/test/fuzztest/powerhdistub_fuzzer/powerhdistub_fuzz.cpp @@ -68,9 +68,6 @@ static void PowerStubFuzzTest(const uint8_t *data, size_t size) } MessageParcel datas; - datas.WriteInterfaceToken(IPowerInterface::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(REWIND_READ_DATA); MessageParcel reply; MessageOption option; if (g_fuzzService == nullptr) { @@ -82,6 +79,9 @@ static void PowerStubFuzzTest(const uint8_t *data, size_t size) if (CMD_POWER_INTERFACE_FORCE_SUSPEND == code) { continue; } + datas.WriteInterfaceToken(IPowerInterface::GetDescriptor()); + datas.WriteBuffer(data, size); + datas.RewindRead(REWIND_READ_DATA); g_fuzzService->OnRemoteRequest(code, datas, reply, option); } } diff --git a/thermal/test/fuzztest/thermalhdistub_fuzzer/thermalhdistub_fuzz.cpp b/thermal/test/fuzztest/thermalhdistub_fuzzer/thermalhdistub_fuzz.cpp index baa310d888..28c5df246e 100644 --- a/thermal/test/fuzztest/thermalhdistub_fuzzer/thermalhdistub_fuzz.cpp +++ b/thermal/test/fuzztest/thermalhdistub_fuzzer/thermalhdistub_fuzz.cpp @@ -49,15 +49,15 @@ static void ThermalStubFuzzTest(const uint8_t *data, size_t size) } MessageParcel datas; - datas.WriteInterfaceToken(IThermalInterface::GetDescriptor()); - datas.WriteBuffer(data, size); - datas.RewindRead(REWIND_READ_DATA); MessageParcel reply; MessageOption option; if (g_fuzzService == nullptr) { g_fuzzService = make_shared(new ThermalInterfaceImpl()); } for (code = CMD_THERMAL_INTERFACE_GET_VERSION; code < THERMAL_INTERFACE_STUB_FUNC_MAX_SIZE; code++) { + datas.WriteInterfaceToken(IThermalInterface::GetDescriptor()); + datas.WriteBuffer(data, size); + datas.RewindRead(REWIND_READ_DATA); g_fuzzService->OnRemoteRequest(code, datas, reply, option); } } -- Gitee From ea8ccf5ef5a8585d2ec797e3e6f995f0c1f5a78d Mon Sep 17 00:00:00 2001 From: w30042960 Date: Tue, 20 Aug 2024 20:05:47 +0800 Subject: [PATCH 0263/1485] add ext2 Signed-off-by: w30042960 --- .../v1_0/include/audio_capture_ext_impl.h | 116 +++++ .../audio/v1_0/src/audio_capture_ext_impl.cpp | 410 ++++++++++++++++++ 2 files changed, 526 insertions(+) create mode 100644 distributed_audio/hdi_service/audio/v1_0/include/audio_capture_ext_impl.h create mode 100644 distributed_audio/hdi_service/audio/v1_0/src/audio_capture_ext_impl.cpp diff --git a/distributed_audio/hdi_service/audio/v1_0/include/audio_capture_ext_impl.h b/distributed_audio/hdi_service/audio/v1_0/include/audio_capture_ext_impl.h new file mode 100644 index 0000000000..e006772a52 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/include/audio_capture_ext_impl.h @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_AUDIO_CAPTURE_EXT_IMPL_H +#define OHOS_AUDIO_CAPTURE_EXT_IMPL_H + +#include +#include +#include + +#include +#include +#include + +#include "ashmem.h" +#include "audio_capture_interface_impl_base.h" +#include "daudio_utils.h" + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::CurrentTime; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioCallback; +class AudioCaptureExtImpl : public AudioCaptureInterfaceImplBase { +public: + AudioCaptureExtImpl(); + ~AudioCaptureExtImpl() override; + + int32_t CaptureFrame(std::vector &frame, uint64_t &replyBytes) override; + int32_t GetCapturePosition(uint64_t &frames, AudioTimeStamp &time) override; + int32_t CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported) override; + int32_t SelectScene(const AudioSceneDescriptor &scene) override; + int32_t SetMute(bool mute) override; + int32_t GetMute(bool &mute) override; + int32_t SetVolume(float volume) override; + int32_t GetVolume(float &volume) override; + int32_t GetGainThreshold(float &min, float &max) override; + int32_t GetGain(float &gain) override; + int32_t SetGain(float gain) override; + int32_t GetFrameSize(uint64_t &size) override; + int32_t GetFrameCount(uint64_t &count) override; + int32_t SetSampleAttributes(const AudioSampleAttributes &attrs) override; + int32_t GetSampleAttributes(AudioSampleAttributes &attrs) override; + int32_t GetCurrentChannelId(uint32_t &channelId) override; + int32_t SetExtraParams(const std::string &keyValueList) override; + int32_t GetExtraParams(std::string &keyValueList) override; + int32_t ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc) override; + int32_t GetMmapPosition(uint64_t &frames, AudioTimeStamp &time) override; + int32_t AddAudioEffect(uint64_t effectid) override; + int32_t RemoveAudioEffect(uint64_t effectid) override; + int32_t GetFrameBufferSize(uint64_t &bufferSize) override; + int32_t Start() override; + int32_t Stop() override; + int32_t Pause() override; + int32_t Resume() override; + int32_t Flush() override; + int32_t TurnStandbyMode() override; + int32_t AudioDevDump(int32_t range, int32_t fd) override; + int32_t IsSupportsPauseAndResume(bool &supportPause, bool &supportResume) override; + const AudioDeviceDescriptor &GetCaptureDesc() override; + void SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, + const sptr &callback, const int32_t dhId) override; + void SetDumpFlagInner() override; + +private: + int32_t InitAshmem(int32_t ashmemLength); + void UnInitAshmem(); +private: + std::string adapterName_; + int32_t dhId_ = 0; + uint32_t captureId_ = 0; + AudioDeviceDescriptor devDesc_ = {}; + AudioSampleAttributes devAttrs_ = {}; + uint32_t timeInterval_ = AUDIO_MMAP_NOIRQ_INTERVAL; + uint32_t minTimeInterval_ = 30; + uint32_t maxTimeInterval_ = 80; + + std::mutex captureMtx_; + AudioCaptureStatus captureStatus_ = CAPTURE_STATUS_CLOSE; + sptr audioExtCallback_ = nullptr; + OHOS::sptr ashmem_ = nullptr; + int32_t ashmemLength_ = 0; + int32_t lengthPerTrans_ = 0; + int32_t fd_ = 0; +}; + +#ifdef __cplusplus +extern "C" { +#endif +__attribute__((visibility("default"))) AudioCaptureInterfaceImplBase *GetCaptureImplExt(); +#ifdef __cplusplus +} +#endif +} // namespace V1_0 +} // namespace Audio +} // namespace DistributedAudio +} // namespace HDI +} // namespace OHOS +#endif // OHOS_AUDIO_CAPTURE_EXT_IMPL_H diff --git a/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_ext_impl.cpp b/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_ext_impl.cpp new file mode 100644 index 0000000000..2a56611064 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_ext_impl.cpp @@ -0,0 +1,410 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_capture_ext_impl.h" + +#include +#include +#include +#include + +#include "cJSON.h" + +#include "daudio_constants.h" +#include "daudio_events.h" +#include "daudio_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AudioCaptureExtImpl" + +using namespace OHOS::DistributedHardware; +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { + +AudioCaptureExtImpl::AudioCaptureExtImpl() +{ + DHLOGI("Distributed lowlatency capture constructed."); +} + +AudioCaptureExtImpl::~AudioCaptureExtImpl() +{ + UnInitAshmem(); + DHLOGD("Distributed lowlatency capture destructed, id(%{public}d).", devDesc_.pins); +} + +int32_t AudioCaptureExtImpl::InitAshmem(int32_t ashmemLength) +{ + std::string memory_name = "Capture ShareMemory"; + if (ashmemLength < DAUDIO_MIN_ASHMEM_LEN || ashmemLength > DAUDIO_MAX_ASHMEM_LEN) { + DHLOGE("Init ashmem failed. length is illegal."); + return HDF_FAILURE; + } + ashmem_ = OHOS::Ashmem::CreateAshmem(memory_name.c_str(), ashmemLength); + if (ashmem_ == nullptr) { + DHLOGE("Create ashmem failed."); + return HDF_FAILURE; + } + if (!ashmem_->MapReadAndWriteAshmem()) { + DHLOGE("Mmap ashmem failed."); + return HDF_FAILURE; + } + fd_ = ashmem_->GetAshmemFd(); + DHLOGI("Init Ashmem success, fd: %{public}d, length: %{public}d", fd_, ashmemLength); + return HDF_SUCCESS; +} + +void AudioCaptureExtImpl::UnInitAshmem() +{ + if (ashmem_ != nullptr) { + ashmem_->UnmapAshmem(); + ashmem_->CloseAshmem(); + ashmem_ = nullptr; + DHLOGI("UnInitAshmem success."); + } +} + +int32_t AudioCaptureExtImpl::GetCapturePosition(uint64_t &frames, AudioTimeStamp &time) +{ + DHLOGI("Get capture position, not support yet."); + (void)frames; + (void)time; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::CaptureFrame(std::vector &frame, uint64_t &replyBytes) +{ + DHLOGI("Render frame. not support in low-latency capture"); + (void)devAttrs_.sampleRate; + (void)devAttrs_.channelCount; + (void)devAttrs_.format; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::Start() +{ + DHLOGI("Start capture mmap."); + std::string content; + std::initializer_list> items = { {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + DAudioEvent event = { HDF_AUDIO_EVENT_MMAP_START_MIC, content }; + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + int32_t ret = audioExtCallback_->NotifyEvent(captureId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Start capture mmap failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::Stop() +{ + DHLOGI("Stop capture mmap."); + std::string content; + std::initializer_list> items = { {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + DAudioEvent event = { HDF_AUDIO_EVENT_MMAP_STOP_MIC, content }; + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + int32_t ret = audioExtCallback_->NotifyEvent(captureId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Stop capture mmap failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::Pause() +{ + DHLOGI("Pause capture."); + std::lock_guard captureLck(captureMtx_); + captureStatus_ = CAPTURE_STATUS_PAUSE; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::Resume() +{ + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::Flush() +{ + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::TurnStandbyMode() +{ + DHLOGI("Turn stand by mode, not support yet."); + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::AudioDevDump(int32_t range, int32_t fd) +{ + DHLOGI("Dump audio info, not support yet."); + (void)range; + (void)fd; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::IsSupportsPauseAndResume(bool &supportPause, bool &supportResume) +{ + DHLOGI("Check whether pause and resume is supported, not support yet."); + (void)supportPause; + (void)supportResume; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported) +{ + DHLOGI("Check scene capability."); + (void)scene; + supported = false; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SelectScene(const AudioSceneDescriptor &scene) +{ + DHLOGI("Select audio scene, not support yet."); + (void)scene; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SetMute(bool mute) +{ + DHLOGI("Set mute, not support yet."); + (void)mute; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetMute(bool &mute) +{ + DHLOGI("Get mute, not support yet."); + (void)mute; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SetVolume(float volume) +{ + DHLOGI("Can not set vol not by this interface."); + (void)volume; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetVolume(float &volume) +{ + DHLOGI("Can not get vol not by this interface."); + (void)volume; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetGainThreshold(float &min, float &max) +{ + DHLOGI("Get gain threshold, not support yet."); + min = 0; + max = 0; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SetGain(float gain) +{ + DHLOGI("Set gain, not support yet."); + (void) gain; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetGain(float &gain) +{ + DHLOGI("Get gain, not support yet."); + gain = 1.0; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetFrameSize(uint64_t &size) +{ + (void)size; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetFrameCount(uint64_t &count) +{ + (void)count; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SetSampleAttributes(const AudioSampleAttributes &attrs) +{ + DHLOGI("Set sample attributes."); + devAttrs_ = attrs; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetSampleAttributes(AudioSampleAttributes &attrs) +{ + DHLOGI("Get sample attributes."); + attrs = devAttrs_; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetCurrentChannelId(uint32_t &channelId) +{ + DHLOGI("Get current channel id, not support yet."); + (void)channelId; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::SetExtraParams(const std::string &keyValueList) +{ + DHLOGI("Set extra parameters, not support yet."); + (void)keyValueList; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetExtraParams(std::string &keyValueList) +{ + DHLOGI("Get extra parameters, not support yet."); + (void)keyValueList; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc) +{ + DHLOGI("Request mmap buffer."); + int32_t minSize = CalculateSampleNum(devAttrs_.sampleRate, minTimeInterval_); + int32_t maxSize = CalculateSampleNum(devAttrs_.sampleRate, maxTimeInterval_); + int32_t realSize = reqSize; + if (reqSize < minSize) { + realSize = minSize; + } else if (reqSize > maxSize) { + realSize = maxSize; + } + DHLOGI("ReqMmap buffer realsize : %{public}d, minsize: %{public}d, maxsize:%{public}d.", + realSize, minSize, maxSize); + desc.totalBufferFrames = realSize; + ashmemLength_ = realSize * static_cast(devAttrs_.channelCount) * devAttrs_.format; + DHLOGI("Init ashmem real sample size : %{public}d, length: %{public}d.", realSize, ashmemLength_); + int32_t ret = InitAshmem(ashmemLength_); + if (ret != HDF_SUCCESS) { + DHLOGE("Init ashmem error.."); + return HDF_FAILURE; + } + desc.memoryFd = fd_; + desc.transferFrameSize = static_cast(CalculateSampleNum(devAttrs_.sampleRate, timeInterval_)); + lengthPerTrans_ = desc.transferFrameSize * static_cast(devAttrs_.channelCount) * devAttrs_.format; + desc.isShareable = false; + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + ret = audioExtCallback_->RefreshAshmemInfo(captureId_, fd_, ashmemLength_, lengthPerTrans_); + if (ret != HDF_SUCCESS) { + DHLOGE("Refresh ashmem info failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetMmapPosition(uint64_t &frames, AudioTimeStamp &time) +{ + DHLOGI("Get capture mmap position."); + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + CurrentTime cTime; + int32_t ret = audioExtCallback_->ReadMmapPosition(captureId_, frames, cTime); + if (ret != HDF_SUCCESS) { + DHLOGE("Read mmap position failed."); + return HDF_FAILURE; + } + time.tvSec = cTime.tvSec; + time.tvNSec = cTime.tvNSec; + DHLOGI("Read mmap position. frames: %{public}" PRIu64", tvSec: %{public}" PRId64", tvNSec: %{public}" PRId64, + frames, cTime.tvSec, cTime.tvNSec); + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::AddAudioEffect(uint64_t effectid) +{ + DHLOGI("Add audio effect, not support yet."); + (void)effectid; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::RemoveAudioEffect(uint64_t effectid) +{ + DHLOGI("Remove audio effect, not support yet."); + (void)effectid; + return HDF_SUCCESS; +} + +int32_t AudioCaptureExtImpl::GetFrameBufferSize(uint64_t &bufferSize) +{ + DHLOGI("Get frame buffer size, not support yet."); + (void)bufferSize; + return HDF_SUCCESS; +} + +const AudioDeviceDescriptor &AudioCaptureExtImpl::GetCaptureDesc() +{ + return devDesc_; +} + +void AudioCaptureExtImpl::SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc, + const AudioSampleAttributes &attrs, const sptr &callback, const int32_t dhId) +{ + adapterName_ = adpName; + devDesc_ = desc; + devAttrs_ = attrs; + audioExtCallback_ = callback; + dhId_ = dhId; + if (attrs.type == AUDIO_MMAP_NOIRQ) { + timeInterval_ = AUDIO_MMAP_NOIRQ_INTERVAL; + } else if (attrs.type == AUDIO_MMAP_VOIP) { + timeInterval_ = AUDIO_MMAP_VOIP_INTERVAL; + } + devAttrs_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format, timeInterval_, true); + DHLOGI("Distributed lowlatency capture set attrs, id(%{public}d). framesize(%{public}d)", + dhId_, devAttrs_.frameSize); +} + +void AudioCaptureExtImpl::SetDumpFlagInner() +{ + DHLOGI("Set dump flag, not support yet."); +} + +AudioCaptureInterfaceImplBase *GetCaptureImplExt() +{ + DHLOGI("Get low latency capture impl."); + static AudioCaptureExtImpl *implBase = new AudioCaptureExtImpl(); + return implBase; +} +} // namespace V1_0 +} // namespace Audio +} // namespace Distributedaudio +} // namespace HDI +} // namespace OHOS -- Gitee From 2ffe7b45d52636b8b1c86d1e50ad4e2dc3ba0e7f Mon Sep 17 00:00:00 2001 From: liangqi Date: Mon, 19 Aug 2024 16:35:47 +0800 Subject: [PATCH 0264/1485] =?UTF-8?q?=E5=9C=A8=E4=BD=BF=E7=94=A8deviceName?= =?UTF-8?q?=5F=E5=AD=97=E7=AC=A6=E4=B8=B2=E5=89=8D=EF=BC=8C=E5=AF=B9?= =?UTF-8?q?=E5=85=B6=E8=BF=9B=E8=A1=8C=E6=A0=A1=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liangqi --- .../ddk_service/src/emit_event_manager/virtual_device.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/input/ddk_service/src/emit_event_manager/virtual_device.cpp b/input/ddk_service/src/emit_event_manager/virtual_device.cpp index 394a0a43c7..5d158260d9 100644 --- a/input/ddk_service/src/emit_event_manager/virtual_device.cpp +++ b/input/ddk_service/src/emit_event_manager/virtual_device.cpp @@ -14,6 +14,7 @@ */ #include "virtual_device.h" +#include #include #include #include @@ -97,7 +98,11 @@ bool VirtualDevice::SetUp() return false; } - errno_t ret = strncpy_s(uinputDev_.name, MAX_NAME_LENGTH, deviceName_, sizeof(uinputDev_.name)); + if (strlen(deviceName_) == 0 || strlen(deviceName_) > MAX_NAME_LENGTH - 1) { + HDF_LOGE("%{public}s Length of deviceName_ is out of range", __func__); + return false; + } + errno_t ret = strncpy_s(uinputDev_.name, MAX_NAME_LENGTH, deviceName_, MAX_NAME_LENGTH - 1); if (ret != EOK) { HDF_LOGE("%{public}s Failed to copy deviceName", __func__); return false; -- Gitee From e377338d480dcf11ebb7f1ea3425588bc019d656 Mon Sep 17 00:00:00 2001 From: JillFred <14623865@qq.com> Date: Tue, 20 Aug 2024 20:26:50 +0800 Subject: [PATCH 0265/1485] add new index Signed-off-by: JillFred <14623865@qq.com> --- codec/interfaces/include/codec_omx_ext.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/codec/interfaces/include/codec_omx_ext.h b/codec/interfaces/include/codec_omx_ext.h index 0b1a29fee9..fd8d5f4ddf 100644 --- a/codec/interfaces/include/codec_omx_ext.h +++ b/codec/interfaces/include/codec_omx_ext.h @@ -273,6 +273,8 @@ enum OmxIndexCodecExType { OMX_IndexParamEncOutIRatio, /** OMX_S32 */ OMX_IndexParamEncOutFrameQp, + /** OMX_CONFIG_BOOLEANTYPE */ + OMX_IndexParamSupportPackInput, }; /** -- Gitee From cac18b54bf16341c5e8217c12a4ac3329990a392 Mon Sep 17 00:00:00 2001 From: liufeng Date: Tue, 20 Aug 2024 21:02:11 +0800 Subject: [PATCH 0266/1485] =?UTF-8?q?200~=E8=8A=AF=E7=89=87=E7=BB=84?= =?UTF-8?q?=E4=BB=B6=E7=8B=AC=E7=AB=8B=E6=9E=84=E5=BB=BA=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: liufeng --- camera/bundle.json | 3 ++- camera/test/hdi/metadata_test/BUILD.gn | 3 +++ camera/test/hdi/v1_0/BUILD.gn | 3 +++ camera/test/hdi/v1_1/BUILD.gn | 3 +++ camera/test/ut/buffer_manager/BUILD.gn | 3 +++ camera/test/ut/usb_camera/BUILD.gn | 3 +++ camera/test/ut/v4l2/BUILD.gn | 3 +++ 7 files changed, 20 insertions(+), 1 deletion(-) diff --git a/camera/bundle.json b/camera/bundle.json index 4226be0d0e..7a21b60a90 100644 --- a/camera/bundle.json +++ b/camera/bundle.json @@ -33,7 +33,8 @@ "bounds_checking_function", "libexif", "libjpeg-turbo", - "ffmpeg" + "ffmpeg", + "googletest" ], "third_party": [] }, diff --git a/camera/test/hdi/metadata_test/BUILD.gn b/camera/test/hdi/metadata_test/BUILD.gn index ba1820aa52..8b351fe9a6 100644 --- a/camera/test/hdi/metadata_test/BUILD.gn +++ b/camera/test/hdi/metadata_test/BUILD.gn @@ -68,6 +68,9 @@ ohos_unittest("camera_metadata_operator_ut") { "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:libcamera_proxy_1.0", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "samgr:samgr_proxy", ] diff --git a/camera/test/hdi/v1_0/BUILD.gn b/camera/test/hdi/v1_0/BUILD.gn index b3f97e90e8..350bfda599 100644 --- a/camera/test/hdi/v1_0/BUILD.gn +++ b/camera/test/hdi/v1_0/BUILD.gn @@ -140,6 +140,9 @@ if (defined(ohos_lite)) { "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:libcamera_proxy_1.0", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "samgr:samgr_proxy", ] diff --git a/camera/test/hdi/v1_1/BUILD.gn b/camera/test/hdi/v1_1/BUILD.gn index 2592cf149b..29ac73b017 100644 --- a/camera/test/hdi/v1_1/BUILD.gn +++ b/camera/test/hdi/v1_1/BUILD.gn @@ -74,6 +74,9 @@ ohos_unittest("camera_test_hdi_V1_1") { "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:libcamera_proxy_1.1", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "samgr:samgr_proxy", ] diff --git a/camera/test/ut/buffer_manager/BUILD.gn b/camera/test/ut/buffer_manager/BUILD.gn index deb50b5a7c..d59e7a0899 100644 --- a/camera/test/ut/buffer_manager/BUILD.gn +++ b/camera/test/ut/buffer_manager/BUILD.gn @@ -174,6 +174,9 @@ if (defined(ohos_lite)) { external_deps += [ "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "ipc:ipc_single", "samgr:samgr_proxy", diff --git a/camera/test/ut/usb_camera/BUILD.gn b/camera/test/ut/usb_camera/BUILD.gn index 872b8d3388..84211840f7 100644 --- a/camera/test/ut/usb_camera/BUILD.gn +++ b/camera/test/ut/usb_camera/BUILD.gn @@ -100,6 +100,9 @@ ohos_unittest("camera_usb_test_ut") { "drivers_interface_camera:libcamera_proxy_1.0", "drivers_interface_camera:libcamera_stub_1.0", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "hdf_core:libhdf_utils", "hilog:libhilog", diff --git a/camera/test/ut/v4l2/BUILD.gn b/camera/test/ut/v4l2/BUILD.gn index eef3846882..53209c183a 100644 --- a/camera/test/ut/v4l2/BUILD.gn +++ b/camera/test/ut/v4l2/BUILD.gn @@ -189,6 +189,9 @@ if (defined(ohos_lite)) { external_deps += [ "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:metadata", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "ipc:ipc_single", "samgr:samgr_proxy", -- Gitee From 0f4f6bdaf8b5c398bfaed788c732093637e9bd55 Mon Sep 17 00:00:00 2001 From: w30042960 Date: Wed, 21 Aug 2024 09:25:01 +0800 Subject: [PATCH 0267/1485] add ut Signed-off-by: w30042960 --- .../include/audio_capture_ext_impl_test.h | 55 ++++ .../src/audio_capture_ext_impl_test.cpp | 254 +++++++++++++++ .../include/audio_render_ext_impl_test.h | 55 ++++ .../src/audio_render_ext_impl_test.cpp | 295 ++++++++++++++++++ 4 files changed, 659 insertions(+) create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/include/audio_capture_ext_impl_test.h create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/src/audio_capture_ext_impl_test.cpp create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/include/audio_render_ext_impl_test.h create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/src/audio_render_ext_impl_test.cpp diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/include/audio_capture_ext_impl_test.h b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/include/audio_capture_ext_impl_test.h new file mode 100644 index 0000000000..42b27883f6 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/include/audio_capture_ext_impl_test.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_AUDIO_CAPTURE_EXT_IMPL_TEST_H +#define OHOS_AUDIO_CAPTURE_EXT_IMPL_TEST_H + +#include + +#include +#include +#include + +#include "audio_test_utils.h" +#include "audio_capture_ext_impl.h" + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioCallback; + +class AudioCaptureExtImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::string adpName_; + AudioDeviceDescriptor desc_; + AudioSampleAttributes attrs_; + sptr callback_; + std::shared_ptr audioCapturelatencyImpl_ = nullptr; +}; +} // namespace V1_0 +} // namespace Audio +} // namespace Distributedaudio +} // namespace HDI +} // namespace OHOS +#endif //OHOS_AUDIO_CAPTURE_EXT_IMPL_TEST_H diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/src/audio_capture_ext_impl_test.cpp b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/src/audio_capture_ext_impl_test.cpp new file mode 100644 index 0000000000..bf1207f263 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/src/audio_capture_ext_impl_test.cpp @@ -0,0 +1,254 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_capture_ext_impl_test.h" + +#include +#include +#include + +#include "ashmem.h" +#include "daudio_constants.h" +#include "daudio_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +void AudioCaptureExtImplTest::SetUpTestCase(void) {} + +void AudioCaptureExtImplTest::TearDownTestCase(void) {} + +void AudioCaptureExtImplTest::SetUp(void) {} + +void AudioCaptureExtImplTest::TearDown(void) +{ + audioCapturelatencyImpl_ = nullptr; +} + +/** + * @tc.name: InitAshmem_001 + * @tc.desc: Verify the InitAshmem function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, InitAshmem_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + int32_t ashmemLength = 1024; + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->InitAshmem(ashmemLength)); + audioCapturelatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: InitAshmem_002 + * @tc.desc: Verify the InitAshmem function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, InitAshmem_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + int32_t ashmemLength = -1; + EXPECT_EQ(HDF_FAILURE, audioCapturelatencyImpl_->InitAshmem(ashmemLength)); + audioCapturelatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, Start_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + uint64_t frames = 0; + AudioTimeStamp time; + std::vector frame; + uint64_t requestBytes = 1024; + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetCapturePosition(frames, time)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->CaptureFrame(frame, requestBytes)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->Pause()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->Resume()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->Flush()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->TurnStandbyMode()); + EXPECT_EQ(HDF_FAILURE, audioCapturelatencyImpl_->GetMmapPosition(frames, time)); + audioCapturelatencyImpl_->audioExtCallback_ = sptr(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->Start()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->Stop()); +} + +/** + * @tc.name: Start_002 + * @tc.desc: Verify the Start function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, Start_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + int32_t range = 1; + int32_t fd = 1; + bool supportPause = true; + bool supportResume = true; + AudioSceneDescriptor scene; + bool supported = true; + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->AudioDevDump(range, fd)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->IsSupportsPauseAndResume(supportPause, supportResume)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->CheckSceneCapability(scene, supported)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SelectScene(scene)); + audioCapturelatencyImpl_->audioExtCallback_ = nullptr; + EXPECT_EQ(HDF_FAILURE, audioCapturelatencyImpl_->Start()); +} + +/** + * @tc.name: ReqMmapBuffer_001 + * @tc.desc: Verify the ReqMmapBuffer function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, ReqMmapBuffer_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor descs; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, descs, attrs, callback, dhId); + + int32_t reqSize = 30; + AudioMmapBufferDescriptor desc; + EXPECT_EQ(HDF_FAILURE, audioCapturelatencyImpl_->ReqMmapBuffer(reqSize, desc)); + audioCapturelatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: ReqMmapBuffer_002 + * @tc.desc: Verify the ReqMmapBuffer function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, ReqMmapBuffer_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor descs; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, descs, attrs, callback, dhId); + + int32_t reqSize = 30; + AudioMmapBufferDescriptor desc; + struct AudioSampleAttributes captureAttr = { + .type = AUDIO_IN_MEDIA, + .interleaved = 0, + .format = AUDIO_FORMAT_TYPE_PCM_16_BIT, + .sampleRate = 48000, + .channelCount = 2, + .period = 1024, + .frameSize = 4, + .isBigEndian = false, + .isSignedData = true, + .startThreshold = 1024, + .stopThreshold = 0x7fffffff, + .silenceThreshold = 0, + .streamId = 1, + }; + audioCapturelatencyImpl_->devAttrs_ = captureAttr; + audioCapturelatencyImpl_->audioExtCallback_ = sptr(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->ReqMmapBuffer(reqSize, desc)); + audioCapturelatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: SetMute_001 + * @tc.desc: Verify the SetMute function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioCaptureExtImplTest, SetMute_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attr; + sptr callback; + int32_t dhId = 1; + audioCapturelatencyImpl_ = std::make_shared(); + audioCapturelatencyImpl_->SetAttrs(adpName, desc, attr, callback, dhId); + + bool mute = true; + float volume = 0.0; + float min = 0.0; + float max = 10.0; + uint64_t size = 1024; + uint32_t channelId = 0; + std::string keyValueList = "keyValueList"; + AudioSampleAttributes attrs; + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SetMute(mute)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetMute(mute)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SetVolume(volume)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetGainThreshold(min, max)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SetGain(volume)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetGain(volume)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetFrameSize(size)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetFrameCount(size)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SetSampleAttributes(attrs)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetSampleAttributes(attrs)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetCurrentChannelId(channelId)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->SetExtraParams(keyValueList)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetExtraParams(keyValueList)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->AddAudioEffect(size)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->RemoveAudioEffect(size)); + EXPECT_EQ(HDF_SUCCESS, audioCapturelatencyImpl_->GetFrameBufferSize(size)); +} +} // namspace V1_0 +} // namspace Audio +} // namspace Distributedaudio +} // namspace HDI +} // namspace OHOS diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/include/audio_render_ext_impl_test.h b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/include/audio_render_ext_impl_test.h new file mode 100644 index 0000000000..ef1480771a --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/include/audio_render_ext_impl_test.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_AUDIO_RENDER_EXT_IMPL_TEST_H +#define OHOS_AUDIO_RENDER_EXT_IMPL_TEST_H + +#include + +#include +#include +#include + +#include "audio_test_utils.h" +#include "audio_render_ext_impl.h" + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioCallback; + +class AudioRenderExtImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::string adpName_; + AudioDeviceDescriptor desc_; + AudioSampleAttributes attrs_; + sptr callback_; + std::shared_ptr audioRenderlatencyImpl_ = nullptr; +}; +} // namespace V1_0 +} // namespace Audio +} // namespace Distributedaudio +} // namespace HDI +} // namespace OHOS +#endif //OHOS_AUDIO_RENDER_EXT_IMPL_TEST_H diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/src/audio_render_ext_impl_test.cpp b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/src/audio_render_ext_impl_test.cpp new file mode 100644 index 0000000000..dc1eb481ff --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/src/audio_render_ext_impl_test.cpp @@ -0,0 +1,295 @@ +/* + * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_render_ext_impl_test.h" + +#include +#include +#include + +#include "ashmem.h" +#include "daudio_constants.h" +#include "daudio_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +void AudioRenderExtImplTest::SetUpTestCase(void) {} + +void AudioRenderExtImplTest::TearDownTestCase(void) {} + +void AudioRenderExtImplTest::SetUp(void) {} + +void AudioRenderExtImplTest::TearDown(void) +{ + audioRenderlatencyImpl_ = nullptr; +} + +/** + * @tc.name: InitAshmem_001 + * @tc.desc: Verify the InitAshmem function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, InitAshmem_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + int fd = 1; + uint32_t ms = 0; + float speed = 0.0; + uint64_t replyBytes = 0; + int32_t ashmemLength = 1024; + const std::vector frame; + AudioTimeStamp time; + audioRenderlatencyImpl_->audioExtCallback_ = sptr(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->InitAshmem(ashmemLength)); + audioRenderlatencyImpl_->UnInitAshmem(); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetRenderPosition(replyBytes, time)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->RenderFrame(frame, replyBytes)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetLatency(ms)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetRenderSpeed(speed)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetRenderSpeed(speed)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetVolume(speed)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetVolume(speed)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->AudioDevDump(ashmemLength, fd)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetMmapPosition(replyBytes, time)); +} + +/** + * @tc.name: InitAshmem_002 + * @tc.desc: Verify the InitAshmem function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, InitAshmem_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + int8_t cookie = 0; + bool support = true; + int32_t ashmemLength = -1; + AudioDrainNotifyType type; + AudioSceneDescriptor scene; + sptr audioCallback = nullptr; + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->Pause()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->Resume()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->Flush()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->TurnStandbyMode()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->DrainBuffer(type)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->IsSupportsPauseAndResume(support, support)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->CheckSceneCapability(scene, support)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SelectScene(scene)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetMute(support)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetMute(support)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->IsSupportsDrain(support)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->RegCallback(audioCallback, cookie)); + EXPECT_EQ(HDF_FAILURE, audioRenderlatencyImpl_->InitAshmem(ashmemLength)); + audioRenderlatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: GetFadeRate_001 + * @tc.desc: Verify the GetFadeRate function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, GetFadeRate_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attr; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attr, callback, dhId); + + float min = 0.0; + float max = 10.0; + uint64_t size = 1024; + uint32_t currentIndex = 2; + const uint32_t durationIndex = 5; + AudioSampleAttributes attrs; + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetGainThreshold(min, max)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetGain(min)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetGain(min)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetFrameSize(size)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetFrameCount(size)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetSampleAttributes(attrs)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetSampleAttributes(attrs)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetCurrentChannelId(currentIndex)); + float fadeRate = audioRenderlatencyImpl_->GetFadeRate(currentIndex, durationIndex); + EXPECT_LE(0, fadeRate); + EXPECT_GE(0.5f, fadeRate); +} + +/** + * @tc.name: FadeInprocess_001 + * @tc.desc: Verify the FadeInprocess function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, FadeInProcess_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + uint64_t effectid = 0; + std::string keyValueList = "keyValueList"; + const uint32_t durationFrame = 10; + const size_t frameLength = 4096; + int8_t* frameData = new int8_t[frameLength]; + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->SetExtraParams(keyValueList)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetExtraParams(keyValueList)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->AddAudioEffect(effectid)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->RemoveAudioEffect(effectid)); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->GetFrameBufferSize(effectid)); + EXPECT_EQ(0, audioRenderlatencyImpl_->GetVolumeInner()); + EXPECT_EQ(0, audioRenderlatencyImpl_->GetMaxVolumeInner()); + EXPECT_EQ(0, audioRenderlatencyImpl_->GetMinVolumeInner()); + audioRenderlatencyImpl_->SetVolumeInner(durationFrame); + audioRenderlatencyImpl_->SetVolumeRangeInner(durationFrame, durationFrame); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->FadeInProcess(durationFrame, frameData, frameLength)); + delete[] frameData; + frameData = nullptr; +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Start function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, Start_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + audioRenderlatencyImpl_->audioExtCallback_ = sptr(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->Start()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->Stop()); +} + +/** + * @tc.name: Start_002 + * @tc.desc: Verify the Start function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, Start_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor desc; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, desc, attrs, callback, dhId); + + audioRenderlatencyImpl_->audioExtCallback_ = nullptr; + EXPECT_EQ(HDF_FAILURE, audioRenderlatencyImpl_->Start()); +} + +/** + * @tc.name: ReqMmapBuffer_001 + * @tc.desc: Verify the ReqMmapBuffer function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, ReqMmapBuffer_001, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor descs; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, descs, attrs, callback, dhId); + + int32_t reqSize = 30; + AudioMmapBufferDescriptor desc; + EXPECT_EQ(HDF_FAILURE, audioRenderlatencyImpl_->ReqMmapBuffer(reqSize, desc)); + audioRenderlatencyImpl_->UnInitAshmem(); +} + +/** + * @tc.name: ReqMmapBuffer_002 + * @tc.desc: Verify the ReqMmapBuffer function. + * @tc.type: FUNC + * @tc.require: AR000HP6J4 + */ +HWTEST_F(AudioRenderExtImplTest, ReqMmapBuffer_002, TestSize.Level1) +{ + std::string adpName; + AudioDeviceDescriptor descs; + AudioSampleAttributes attrs; + sptr callback; + int32_t dhId = 1; + audioRenderlatencyImpl_ = std::make_shared(); + audioRenderlatencyImpl_->SetAttrs(adpName, descs, attrs, callback, dhId); + + int32_t reqSize = 30; + AudioMmapBufferDescriptor desc; + struct AudioSampleAttributes renderAttr = { + .type = AUDIO_IN_MEDIA, + .interleaved = 0, + .format = AUDIO_FORMAT_TYPE_PCM_16_BIT, + .sampleRate = 48000, + .channelCount = 2, + .period = 1024, + .frameSize = 4, + .isBigEndian = false, + .isSignedData = true, + .startThreshold = 1024, + .stopThreshold = 0x7fffffff, + .silenceThreshold = 0, + .streamId = 1, + }; + audioRenderlatencyImpl_->devAttrs_ = renderAttr; + audioRenderlatencyImpl_->audioExtCallback_ = sptr(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, audioRenderlatencyImpl_->ReqMmapBuffer(reqSize, desc)); + audioRenderlatencyImpl_->UnInitAshmem(); +} +} // namspace V1_0 +} // namspace Audio +} // namspace Distributedaudio +} // namspace HDI +} // namspace OHOS -- Gitee From 9ac6f8ebdd3876c921b9bc5bf8d30ec2b6b49870 Mon Sep 17 00:00:00 2001 From: hui Date: Mon, 19 Aug 2024 19:24:54 +0800 Subject: [PATCH 0268/1485] Add configuration item Signed-off-by: hui --- bluetooth/audio/hal/hdi_passthrough/BUILD.gn | 4 ++-- bluetooth/bundle.json | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn index 9b976aab63..b8a0e7121a 100644 --- a/bluetooth/audio/hal/hdi_passthrough/BUILD.gn +++ b/bluetooth/audio/hal/hdi_passthrough/BUILD.gn @@ -16,7 +16,7 @@ import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") import("//drivers/peripheral/audio/audio.gni") declare_args() { - bluetooth_a2dp_hdi = false + drivers_peripheral_bluetooth_a2dp_hdi = false } config("hdi_audio_config") { @@ -45,7 +45,7 @@ config("hdi_audio_config") { } ohos_shared_library("hdi_audio_bluetooth") { - if (bluetooth_a2dp_hdi) { + if (drivers_peripheral_bluetooth_a2dp_hdi) { defines = [ "A2DP_HDI_SERVICE" ] } diff --git a/bluetooth/bundle.json b/bluetooth/bundle.json index 4ef30afb14..5f82958b65 100644 --- a/bluetooth/bundle.json +++ b/bluetooth/bundle.json @@ -12,6 +12,7 @@ "component": { "name": "drivers_peripheral_bluetooth", "subsystem": "hdf", + "features": ["drivers_peripheral_bluetooth_a2dp_hdi"], "adapted_system_type": ["standard"], "rom": "615KB", "ram": "7400KB", -- Gitee From 532471794de5fb8227b63c288c0dcc45bb27bcc1 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Wed, 21 Aug 2024 10:26:22 +0800 Subject: [PATCH 0269/1485] codec HDI sync Signed-off-by: suxiaosu007 --- .../fuzztest/image_fuzzer/common/include/image_auto_initer.h | 2 +- codec/test/fuzztest/image_fuzzer/common/include/image_common.h | 2 +- .../imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp | 2 +- .../imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h b/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h index b23c6ae688..2ee02506b8 100644 --- a/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h +++ b/codec/test/fuzztest/image_fuzzer/common/include/image_auto_initer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Shenzhen Kaihong DID Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/codec/test/fuzztest/image_fuzzer/common/include/image_common.h b/codec/test/fuzztest/image_fuzzer/common/include/image_common.h index 657c82c318..b20d33ae5e 100644 --- a/codec/test/fuzztest/image_fuzzer/common/include/image_common.h +++ b/codec/test/fuzztest/image_fuzzer/common/include/image_common.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Shenzhen Kaihong DID Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp index c8323f0f7b..c2b246dd7b 100644 --- a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h index 049ceca011..4d3bf8b8bc 100644 --- a/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h +++ b/codec/test/fuzztest/image_fuzzer/imagedoheifencode_fuzzer/imagedoheifencode_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Shenzhen Kaihong DID Co., Ltd. + * Copyright (c) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at -- Gitee From 22f311f88e9cbb454587d9bce2668506772eb1c9 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Wed, 21 Aug 2024 09:12:29 +0800 Subject: [PATCH 0270/1485] =?UTF-8?q?=E5=A2=9E=E5=BC=BAUSBhost=E5=85=BC?= =?UTF-8?q?=E5=AE=B9=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hechaofan --- usb/ddk/host/src/linux_adapter.c | 2 +- usb/ddk/host/src/usb_raw_api_library.c | 5 ----- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 245e497330..970b6a4f53 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -1014,7 +1014,7 @@ static int32_t AdapterGetConfigDescriptor(const struct UsbDevice *dev, uint8_t c struct UsbDeviceConfigDescriptor *config = NULL; uint8_t i; - if (dev == NULL || buffer == NULL || (configIndex > dev->deviceDescriptor.bNumConfigurations)) { + if (dev == NULL || buffer == NULL) { HDF_LOGE("%{public}s:%{public}d Invalid param", __func__, __LINE__); return HDF_ERR_INVALID_PARAM; } diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 26fb5e1ce2..1163dd52e9 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1237,11 +1237,6 @@ int32_t RawGetConfigDescriptor( return HDF_ERR_INVALID_PARAM; } - if (configIndex > dev->deviceDescriptor.bNumConfigurations) { - HDF_LOGE("%{public}s:%{public}d invalid param", __func__, __LINE__); - return HDF_ERR_BAD_FD; - } - ret = GetConfigDescriptor(dev, configIndex, tmpConfig.buf, sizeof(tmpConfig.buf)); if (ret < HDF_SUCCESS) { HDF_LOGE("%{public}s:%{public}d ret=%{public}d", __func__, __LINE__, ret); -- Gitee From 127f30c8dfa82dacb68fd8372225128f0dd57f22 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Wed, 21 Aug 2024 14:36:08 +0800 Subject: [PATCH 0271/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=81=E7=9A=84?= =?UTF-8?q?=E4=BD=9C=E7=94=A8=E8=8C=83=E5=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- .../primary_impl/vdi_src/audio_manager_vdi.c | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index a1e49582be..bb893d726a 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -228,12 +228,10 @@ int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, struct AudioAdapterDescriptor *descs, uint32_t *descsLen) { int32_t ret; - pthread_mutex_lock(&g_managerMutex); priv->vdiDescs = (struct AudioAdapterDescriptorVdi *)OsalMemCalloc( sizeof(struct AudioAdapterDescriptorVdi) * (*descsLen)); if (priv->vdiDescs == NULL) { AUDIO_FUNC_LOGE("null point"); - pthread_mutex_unlock(&g_managerMutex); return HDF_ERR_NOT_SUPPORT; } @@ -246,10 +244,8 @@ int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, free(priv->vdiDescs); priv->vdiDescs = NULL; priv->vdiDescsCount = 0; - pthread_mutex_unlock(&g_managerMutex); return HDF_FAILURE; } - pthread_mutex_unlock(&g_managerMutex); ret = AudioManagerVdiDescsToDescs(priv->vdiDescs, priv->vdiDescsCount, descs, descsLen); if (ret != HDF_SUCCESS) { @@ -294,14 +290,16 @@ int32_t AudioManagerVendorGetAllAdapters(struct IAudioManager *manager, AUDIO_FUNC_LOGE("audio adapter num demanded too large"); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_managerMutex); if (priv->vdiDescsCount != 0 && priv->vdiDescs != NULL && priv->vdiDescsCount >= *descsLen) { int32_t ret = AudioManagerVdiDescsToDescs(priv->vdiDescs, priv->vdiDescsCount, descs, descsLen); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("audio vdiManager DescsVdi To Descs fail, ret=%{public}d", ret); AudioManagerReleaseDescs(descs, *descsLen); + pthread_mutex_unlock(&g_managerMutex); return HDF_FAILURE; } + pthread_mutex_unlock(&g_managerMutex); return HDF_SUCCESS; } @@ -310,7 +308,9 @@ int32_t AudioManagerVendorGetAllAdapters(struct IAudioManager *manager, priv->vdiDescs = NULL; } - return AudioManagerPrivVdiGetAllAdapters(priv, descs, descsLen); + int32_t ret = AudioManagerPrivVdiGetAllAdapters(priv, descs, descsLen); + pthread_mutex_unlock(&g_managerMutex); + return ret; } static uint32_t AudioManagerVendorFindAdapterPos(struct IAudioManager *manager, const char *adapterName) @@ -340,15 +340,20 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager->LoadAdapter, HDF_ERR_INVALID_PARAM); + pthread_mutex_lock(&g_managerMutex); uint32_t descIndex = AudioManagerVendorFindAdapterPos(manager, desc->adapterName); if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) { AUDIO_FUNC_LOGE("audio vdiManager find adapter pos"); + pthread_mutex_unlock(&g_managerMutex); return HDF_FAILURE; } + int32_t ret = HDF_SUCCESS; uint32_t count = AudioGetAdapterRefCntVdi(descIndex); if (count > 0 && count != UINT_MAX) { - return AudioIncreaseAdapterRefVdi(descIndex, adapter); + ret = AudioIncreaseAdapterRefVdi(descIndex, adapter); + pthread_mutex_unlock(&g_managerMutex); + return ret; } struct AudioAdapterDescriptorVdi vdiDesc = {0}; @@ -356,10 +361,10 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc if (ret != HDF_SUCCESS) { AudioManagerReleaseVdiDesc(&vdiDesc); AUDIO_FUNC_LOGE("audio vdiManager desc To vdiDesc fail, ret=%{public}d", ret); + pthread_mutex_unlock(&g_managerMutex); return HDF_FAILURE; } - pthread_mutex_lock(&g_managerMutex); struct IAudioAdapterVdi *vdiAdapter = NULL; int32_t id = SetTimer("Hdi:LoadAdapter"); HdfAudioStartTrace("Hdi:AudioManagerVendorLoadAdapter", 0); -- Gitee From 8286c8d66e36aad717f7898c9a714af59635bba2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=B8=B0?= Date: Wed, 21 Aug 2024 07:20:30 +0000 Subject: [PATCH 0272/1485] update camera/test/ut/buffer_manager/BUILD.gn. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘丰 --- camera/test/ut/buffer_manager/BUILD.gn | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/camera/test/ut/buffer_manager/BUILD.gn b/camera/test/ut/buffer_manager/BUILD.gn index d59e7a0899..3a5da796e2 100644 --- a/camera/test/ut/buffer_manager/BUILD.gn +++ b/camera/test/ut/buffer_manager/BUILD.gn @@ -174,9 +174,9 @@ if (defined(ohos_lite)) { external_deps += [ "drivers_interface_camera:libbuffer_producer_sequenceable_1.0", "drivers_interface_camera:metadata", - "googletest:gmock_main", - "googletest:gtest", - "googletest:gtest_main", + "googletest:gmock_main", + "googletest:gtest", + "googletest:gtest_main", "graphic_surface:surface", "ipc:ipc_single", "samgr:samgr_proxy", -- Gitee From b8e3b4567823ae114c71279d3eb9a07aadeb0378 Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 20 Aug 2024 16:00:17 +0800 Subject: [PATCH 0273/1485] =?UTF-8?q?=E7=8B=AC=E7=AB=8B=E7=BC=96=E8=AF=91?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/hal/BUILD.gn | 6 +--- input/hdi_service/BUILD.gn | 1 - input/interfaces/include/input_type.h | 36 ++++++++++++++++--- input/test/benchmarktest/BUILD.gn | 1 - input/test/unittest/BUILD.gn | 1 - input/test/unittest/hdi/BUILD.gn | 1 - .../hdi_passthrough_additional/BUILD.gn | 1 - 7 files changed, 33 insertions(+), 14 deletions(-) diff --git a/input/hal/BUILD.gn b/input/hal/BUILD.gn index 45f9e21492..c140484af6 100644 --- a/input/hal/BUILD.gn +++ b/input/hal/BUILD.gn @@ -21,7 +21,6 @@ if (defined(ohos_lite)) { "include", "$INPUT_ROOT_DIR/interfaces/include", "//third_party/bounds_checking_function/include", - "//third_party/FreeBSD/sys/dev/evdev", ] } @@ -63,10 +62,7 @@ if (defined(ohos_lite)) { } else { config("input_hdi_public_config") { visibility = [ ":*" ] - include_dirs = [ - "$INPUT_ROOT_DIR/interfaces/include", - "//third_party/FreeBSD/sys/dev/evdev", - ] + include_dirs = [ "$INPUT_ROOT_DIR/interfaces/include" ] } ohos_shared_library("hdi_input") { diff --git a/input/hdi_service/BUILD.gn b/input/hdi_service/BUILD.gn index 226aad81fc..0b7d77f0f5 100644 --- a/input/hdi_service/BUILD.gn +++ b/input/hdi_service/BUILD.gn @@ -20,7 +20,6 @@ ohos_shared_library("libinput_interfaces_service_1.0") { "$INPUT_ROOT_DIR/interfaces/include/", "$INPUT_ROOT_DIR/utils/include", "$INPUT_ROOT_DIR/hal/include/", - "//third_party/FreeBSD/sys/dev/evdev", ] if (drivers_peripheral_input_feature_model) { deps = [ "$INPUT_ROOT_DIR/hal:hdi_input" ] diff --git a/input/interfaces/include/input_type.h b/input/interfaces/include/input_type.h index 2725a16d04..d9d0c175b0 100644 --- a/input/interfaces/include/input_type.h +++ b/input/interfaces/include/input_type.h @@ -42,14 +42,42 @@ #include #include -#ifndef _UAPI_INPUT_H -#include -#endif - #ifdef __cplusplus extern "C" { #endif +#ifndef _UAPI_INPUT_H +#define INPUT_PROP_MAX 0x1f +#define INPUT_PROP_CNT (INPUT_PROP_MAX + 1) +#define EV_SYN 0x00 +#define EV_KEY 0x01 +#define EV_REL 0x02 +#define EV_ABS 0x03 +#define EV_MAX 0x1f +#define EV_CNT (EV_MAX + 1) +#define ABS_X 0x00 +#define ABS_Y 0x01 +#define ABS_MAX 0x3f +#define ABS_CNT (ABS_MAX + 1) +#define REL_X 0x00 +#define REL_Y 0x01 +#define REL_MAX 0x0f +#define REL_CNT (REL_MAX + 1) +#define KEY_MAX 0x2ff +#define KEY_CNT (KEY_MAX + 1) +#define LED_MAX 0x0f +#define LED_CNT (LED_MAX + 1) +#define MSC_MAX 0x07 +#define MSC_CNT (MSC_MAX + 1) +#define SND_MAX 0x07 +#define SND_CNT (SND_MAX + 1) +#define SW_MAX 0x0f +#define SW_CNT (SW_MAX + 1) +#define BTN_MOUSE 0x110 +#define BTN_TOUCH 0x14a +#define SYN_REPORT 0 +#endif + /** Maximum number of input devices */ #define MAX_INPUT_DEV_NUM 32 /** Length of chip information */ diff --git a/input/test/benchmarktest/BUILD.gn b/input/test/benchmarktest/BUILD.gn index 4085ceacb0..d9f8f72a9d 100644 --- a/input/test/benchmarktest/BUILD.gn +++ b/input/test/benchmarktest/BUILD.gn @@ -22,7 +22,6 @@ ohos_benchmarktest("hdf_input_benchmark_test") { "$INPUT_ROOT_DIR/hdi_service", "$INPUT_ROOT_DIR/interfaces/include", "$INPUT_ROOT_DIR/test/common/include", - "//third_party/FreeBSD/sys/dev/evdev", ] sources = [ diff --git a/input/test/unittest/BUILD.gn b/input/test/unittest/BUILD.gn index 6d2a55a71a..6c6a94caad 100644 --- a/input/test/unittest/BUILD.gn +++ b/input/test/unittest/BUILD.gn @@ -31,7 +31,6 @@ if (defined(ohos_lite)) { "$INPUT_ROOT_DIR/hal/include", "$INPUT_ROOT_DIR/interfaces/include", "$INPUT_ROOT_DIR/utils/include", - "//third_party/FreeBSD/sys/dev/evdev", ] sources = [ "./common/hdi_input_test.cpp" ] diff --git a/input/test/unittest/hdi/BUILD.gn b/input/test/unittest/hdi/BUILD.gn index 14cc0d9caf..35088eed54 100644 --- a/input/test/unittest/hdi/BUILD.gn +++ b/input/test/unittest/hdi/BUILD.gn @@ -26,7 +26,6 @@ ohos_unittest("hdi_unittest_input") { "$INPUT_ROOT_DIR/interfaces", "$INPUT_ROOT_DIR/utils/include", "$INPUT_ROOT_DIR/test/common/include", - "//third_party/FreeBSD/sys/dev/evdev", ] sources = [ diff --git a/input/test/unittest/hdi_passthrough_additional/BUILD.gn b/input/test/unittest/hdi_passthrough_additional/BUILD.gn index c27c1cd6e5..87e39b09db 100644 --- a/input/test/unittest/hdi_passthrough_additional/BUILD.gn +++ b/input/test/unittest/hdi_passthrough_additional/BUILD.gn @@ -52,7 +52,6 @@ config("hdf_input_through_additional") { include_dirs = [ "$INPUT_ROOT_DIR/interfaces/include", "$INPUT_ROOT_DIR/interfaces", - "//third_party/FreeBSD/sys/dev/evdev", "$INPUT_ROOT_DIR/hdi_service", ] } -- Gitee From b5486b997510da4b6e78da4a17aabf9da087f478 Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Wed, 21 Aug 2024 15:57:03 +0800 Subject: [PATCH 0274/1485] heif peripheral Signed-off-by: huangshengqing --- camera/interfaces/include/video_key_info.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/camera/interfaces/include/video_key_info.h b/camera/interfaces/include/video_key_info.h index c66e958e6a..df9ea45403 100644 --- a/camera/interfaces/include/video_key_info.h +++ b/camera/interfaces/include/video_key_info.h @@ -94,5 +94,11 @@ const int32_t VIDEO_KEY_IMAGE_SCORE = 0x09; const std::string deferredImageFormat = "deferredImageFormat"; const int32_t VIDEO_KEY_DEFERRED_IMAGE_FORMAT = 0x0A; +/** + * @brief Indicates the quality level of depth data. The value type is int32_t. + */ +const std::string depthDataQualityLevel = "depthDataQualityLevel"; +const int32_t VIDEO_KEY_DEPTH_DATA_QUALITY_LEVEL = 0x0C; + } // end namespace OHOS::Camera #endif -- Gitee From 5eb77315218652f397844906babad304f88d189f Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Wed, 21 Aug 2024 08:18:38 +0000 Subject: [PATCH 0275/1485] update camera/interfaces/include/video_key_info.h. Signed-off-by: huangshengqing --- camera/interfaces/include/video_key_info.h | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/camera/interfaces/include/video_key_info.h b/camera/interfaces/include/video_key_info.h index df9ea45403..2710b22267 100644 --- a/camera/interfaces/include/video_key_info.h +++ b/camera/interfaces/include/video_key_info.h @@ -94,6 +94,13 @@ const int32_t VIDEO_KEY_IMAGE_SCORE = 0x09; const std::string deferredImageFormat = "deferredImageFormat"; const int32_t VIDEO_KEY_DEFERRED_IMAGE_FORMAT = 0x0A; +/** + * @brief Indicates the count of image. The value type is int32_t. + * include main image and extend images + */ +const std::string imageCount = "imageCount"; +const int32_t VIDEO_KEY_DEFEREED_COUNT = 0x0B; + /** * @brief Indicates the quality level of depth data. The value type is int32_t. */ -- Gitee From 39de05f6aa625aadc8de3330d64a17fe162418c2 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Wed, 21 Aug 2024 08:59:47 +0000 Subject: [PATCH 0276/1485] =?UTF-8?q?CI=E5=AE=89=E5=85=A8=E5=91=8A?= =?UTF-8?q?=E8=AD=A6=E6=95=B4=E6=94=B9=20=E8=B5=84=E6=BA=90=E6=B3=84?= =?UTF-8?q?=E6=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 1 + 1 file changed, 1 insertion(+) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 39c922dffc..9daf386460 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -346,6 +346,7 @@ static int32_t UsbFnAdapterCreatInterface(const char *interfaceName, int32_t nam ret = snprintf_s(fnnew.name, MAX_NAMELEN, MAX_NAMELEN - 1, "%s", interfaceName); if (ret < 0) { HDF_LOGE("%{public}s: snprintf_s failed", __func__); + UsbFnAdapterCloseFn(fd); return HDF_ERR_IO; } ret = ioctl(fd, FUNCTIONFS_NEWFN, &fnnew); -- Gitee From e26c3a10eb7c1b4aebf6cf3eab959667bcc84a06 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:04:13 +0000 Subject: [PATCH 0277/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index 7254ab419b..e052f1dc88 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -104,7 +104,7 @@ WifiError WifiVendorHal::Start() void WifiVendorHal::RunEventLoop() { - pthread_setname_np(pthread_self(), "wlan_chip_event"); + pthread_setname_np(pthread_self(), "VendorHalEventThread"); HDF_LOGD("Starting vendor HAL event loop"); globalFuncTable_.startHalLoop(globalHandle_); const auto lock = AcquireGlobalLock(); -- Gitee From ff5fd8e9ef12947a6326831cff684cb9a51815f1 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 17:13:22 +0800 Subject: [PATCH 0278/1485] =?UTF-8?q?wpa=20host=20=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/wpa/client/src/wpa_client.c | 1 + wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c | 1 + wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h | 1 + wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 1 + wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h | 1 + wlan/wpa/interfaces/hdi_service/service_common/test.c | 0 wlan/wpa/interfaces/hdi_service/service_common/test2.c | 0 wlan/wpa/interfaces/hdi_service/service_common/test3.c | 0 wlan/wpa/interfaces/hdi_service/service_common/test4.c | 0 wlan/wpa/interfaces/hdi_service/service_common/test5.c | 0 wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c | 1 + wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h | 1 + wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c | 1 + 13 files changed, 8 insertions(+) create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test.c create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test2.c create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test3.c create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test4.c create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test5.c diff --git a/wlan/wpa/client/src/wpa_client.c b/wlan/wpa/client/src/wpa_client.c index cd751377ec..f9722c4afd 100644 --- a/wlan/wpa/client/src/wpa_client.c +++ b/wlan/wpa/client/src/wpa_client.c @@ -31,6 +31,7 @@ extern "C" { #define EOK 0 #endif + #define MAX_CALL_BACK_COUNT 10 static struct WpaCallbackEvent *g_wpaCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; static pthread_mutex_t g_wpaCallbackMutex = PTHREAD_MUTEX_INITIALIZER; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index a32421b5ec..8c6e98d09f 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -33,6 +33,7 @@ static pthread_mutex_t g_mutexChba = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_mutexCommon = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_mutexWpa = PTHREAD_MUTEX_INITIALIZER; + int Hex2Dec(const char *str) { if (str == NULL || strncasecmp(str, "0x", strlen("0x")) != 0) { diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h index 9586527bd8..d2c6e6c455 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h @@ -33,6 +33,7 @@ typedef struct StWpaCtrl { struct wpa_ctrl *pRecv; } WpaCtrl; + typedef struct StWpaKeyValue { char key[WPA_MESSAGE_KEY_LENGTH]; char value[WPA_MESSAGE_VALUE_LENGTH]; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index cc7c9850d5..d73dfc723f 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -28,6 +28,7 @@ #undef LOG_TAG #define LOG_TAG "HdiWpaHal" + #define WPA_TRY_CONNECT_TIMES 20 #define WPA_TRY_CONNECT_SLEEP_TIME (100 * 1000) /* 100ms */ #define WPA_CMD_BUF_LEN 256 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h index 794e58e7c0..058232d659 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h @@ -28,6 +28,7 @@ extern "C" { #endif + #define WIFI_CONF_FILE_PATH_LEN 256 typedef struct AddInterfaceArgv { diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test.c b/wlan/wpa/interfaces/hdi_service/service_common/test.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test2.c b/wlan/wpa/interfaces/hdi_service/service_common/test2.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test3.c b/wlan/wpa/interfaces/hdi_service/service_common/test3.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test4.c b/wlan/wpa/interfaces/hdi_service/service_common/test4.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test5.c b/wlan/wpa/interfaces/hdi_service/service_common/test5.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 093a97e172..c3abccb9f7 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -40,6 +40,7 @@ #define BUF_SIZE 512 + pthread_t g_tid; const int QUOTATION_MARKS_FLAG_YES = 0; const int QUOTATION_MARKS_FLAG_NO = 1; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 482123e0af..94281d61fb 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -52,6 +52,7 @@ #define WIFI_NETWORK_CONFIG_VALUE_LENGTH 2048 #define CMD_LEN 6 + int32_t WpaInterfaceStart(struct IWpaInterface *self); int32_t WpaInterfaceStop(struct IWpaInterface *self); int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) ; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c index 8420442479..dde03e0236 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c @@ -32,6 +32,7 @@ #include "bssid_ignore.h" #include "config.h" + #include "v1_1/iwpa_callback.h" #include "v1_1/iwpa_interface.h" -- Gitee From 74d07e8ac5f943b27bc5d42b91f30452104c4ebb Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:28:22 +0000 Subject: [PATCH 0279/1485] update wlan/client/src/netlink/netlink_cmd_adapter.c. Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index 9c4e6b87b7..3389d417d4 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -711,7 +711,7 @@ static int32_t WifiMsgRegisterEventListener(void) g_wifiHalInfo.status = THREAD_STOP; return RET_CODE_FAILURE; } - pthread_setname_np(g_wifiHalInfo.thread, "wlan_event"); + pthread_setname_np(g_wifiHalInfo.thread, "WifiHalEventThread"); // waiting for thread start running while (g_wifiHalInfo.status != THREAD_RUN) { -- Gitee From afe17456c72fe7ef9958a6b0b69561448784890d Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:31:40 +0000 Subject: [PATCH 0280/1485] update wlan/wpa/interfaces/hdi_service/service_common/test.c. Signed-off-by: xionglei --- .../hdi_service/service_common/test.c | 1220 +++++++++++++++++ 1 file changed, 1220 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test.c b/wlan/wpa/interfaces/hdi_service/service_common/test.c index e69de29bb2..87c0e76faf 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/test.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/test.c @@ -0,0 +1,1220 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "wpa_common_cmd.h" +#include "wpa_p2p_cmd.h" +#include "hdi_wpa_hal.h" +#include +#include +#include +#include +#include +#include +#include "utils/common.h" +#include "wpa_supplicant_i.h" +#include "ctrl_iface.h" +#include "main.h" +#include "wps_supplicant.h" +#include "bssid_ignore.h" +#include "wpa_supplicant/config.h" +#include "common/defs.h" +#include "v1_1/iwpa_callback.h" +#include "v1_1/iwpa_interface.h" +#include "wpa_client.h" +#include +#include +#include +#include +#include "hdi_wpa_common.h" + +#define BUF_SIZE 512 + +pthread_t g_tid; +const int QUOTATION_MARKS_FLAG_YES = 0; +const int QUOTATION_MARKS_FLAG_NO = 1; +const int MAX_NETWORKS_NUM = 100; +pthread_mutex_t g_interfaceLock = PTHREAD_MUTEX_INITIALIZER; + +static WpaSsidField g_wpaSsidFields[] = { + {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_PSK, "psk", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_KEYMGMT, "key_mgmt", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_PRIORITY, "priority", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_SCAN_SSID, "scan_ssid", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_EAP, "eap", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_IDENTITY, "identity", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_PASSWORD, "password", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_BSSID, "bssid", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_AUTH_ALGORITHMS, "auth_alg", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_IDX, "wep_tx_keyidx", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_0, "wep_key0", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_1, "wep_key1", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_2, "wep_key2", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_3, "wep_key3", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_EAP_CLIENT_CERT, "client_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_EAP_PRIVATE_KEY, "private_key", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_EAP_PHASE2METHOD, "phase2", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_IEEE80211W, "ieee80211w", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_ALLOW_PROTOCOLS, "proto", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_GROUP_CIPHERS, "group", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_PAIRWISE_CIPHERS, "pairwise", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_SAE_PASSWD, "sae_password", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_CA_CERT, "wapi_ca_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_USER_CERT, "wapi_user_sel_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_PSK_KEY_TYPE, "psk_key_type", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WAPI_PSK, "wapi_psk", QUOTATION_MARKS_FLAG_YES}, +}; + +int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH]) +{ + int flag = g_wpaSsidFields[pos].flag; + const int hexPskMaxLen = 64; + int len = strlen(value); + /* if the psk length is 64, it's hex format and don't need quotation marks */ + if (pos == DEVICE_CONFIG_PSK && len >= hexPskMaxLen) { + flag = QUOTATION_MARKS_FLAG_NO; + } + if (pos == DEVICE_CONFIG_WEP_KEY_0 || + pos == DEVICE_CONFIG_WEP_KEY_1 || + pos == DEVICE_CONFIG_WEP_KEY_2 || + pos == DEVICE_CONFIG_WEP_KEY_3) { + const int wepKeyLen1 = 5; + const int wepKeyLen2 = 13; + const int wepKeyLen3 = 16; + /* For wep key, ASCII format need quotation marks, hex format is not required */ + if (len == wepKeyLen1 || len == wepKeyLen2 || len == wepKeyLen3) { + flag = QUOTATION_MARKS_FLAG_YES; + } + } + return flag; +} + +pthread_mutex_t *GetInterfaceLock() +{ + return &g_interfaceLock; +} + +int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) +{ + if (src == NULL || dst == NULL || dstLen == NULL) { + HDF_LOGE("%{public}s: Invalid parameter!", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); + if (srcLen > 0) { + *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); + if (*dst == NULL) { + HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); + return HDF_FAILURE; + } + if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { + HDF_LOGE("%{public}s: memcpy_s fail!", __func__); + return HDF_FAILURE; + } + } + *dstLen = srcLen; + return HDF_SUCCESS; +} + +struct HdfWpaStubData *HdfWpaStubDriver(void) +{ + static struct HdfWpaStubData registerManager; + return ®isterManager; +} + +int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); + if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + ScanSettings settings = {0}; + settings.scanStyle = SCAN_TYPE_LOW_SPAN; + int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + if (ret == WIFI_HAL_SCAN_BUSY) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: StartScan return scan busy", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: StartScan successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, + uint32_t *resultBufLen) +{ + HDF_LOGI("enter %{public}s", __func__); + (void)self; + if (ifName == NULL || resultBuf == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: Get scan result successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL || networkId == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + *networkId = ret; + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId, const char *name, const char *value) +{ + (void)self; + if (ifName == NULL || name == NULL || value == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGI("enter %{public}s networkId = %{public}d name = %{private}s value = %{private}s", __func__, networkId, + name, value); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaSetNetworkArgv conf = {0}; + conf.id = networkId; + int pos = -1; + for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { + if (strcmp(g_wpaSsidFields[i].fieldName, name) == 0) { + pos = i; + conf.param = g_wpaSsidFields[i].field; + break; + } + } + if (pos < 0) { + HDF_LOGE("%{public}s SetNetwork: unsupported name %{public}s", __func__, name); + return HDF_FAILURE; + } + if (strncpy_s(conf.value, sizeof(conf.value), value, strlen(value)) != 0) { + HDF_LOGE("%{public}s strncpy_s conf.value fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetNetwork(pStaIfc, &conf); + if (ret < 0) { + HDF_LOGE("%{public}s: wpaCliCmdSetNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + HDF_LOGI("%{public}s: wpaCliCmdSetNetwork sucess ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +{ + int32_t ret = HDF_SUCCESS; + + if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { + HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); + if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, + tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, + (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, + (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill flags fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWifiWpaNetworkInfo->bssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->bssid); + hdiWifiWpaNetworkInfo->bssid = NULL; + } + if (hdiWifiWpaNetworkInfo->ssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->ssid); + hdiWifiWpaNetworkInfo->ssid = NULL; + } + if (hdiWifiWpaNetworkInfo->flags != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->flags); + hdiWifiWpaNetworkInfo->flags = NULL; + } + } + return ret; +} + +//need to check +int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, + struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL || networkInfo == NULL || networkInfoLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + int size = MAX_NETWORKS_NUM; + WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(size, sizeof(WifiNetworkInfo)); + if (infos == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: info = NULL", __func__); + return HDF_FAILURE; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + free(infos); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdListNetworks(pStaIfc, infos, &size); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdListNetworks fail! ret = %{public}d", __func__, ret); + free(infos); + return HDF_FAILURE; + } + WifiNetworkInfo *infosTmp = infos; + HDF_LOGI("%{public}s: wpaCliCmdListNetworks success size = %{public}d", __func__, size); + for (int i = 0; i < ((size > MAX_NETWORKS_NUM) ? MAX_NETWORKS_NUM : size); i++) { + WpaFillWpaListNetworkParam(infos, networkInfo); + infos++; + networkInfo++; + } + *networkInfoLen = size; + free(infosTmp); + pthread_mutex_unlock(&g_interfaceLock); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSelectNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSelectNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSelectNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdEnableNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdEnableNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdEnableNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdReconnect(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdReconnect fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdReconnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdDisconnect(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdDisconnect fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdDisconnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, const int32_t enable) +{ + (void)self; + HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdPowerSave(pStaIfc, enable); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdPowerSave fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdPowerSave success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) +{ + (void)self; + HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetAutoConnect(pStaIfc, enable); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSetAutoConnect fail! ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSetAutoConnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) +{ + if (halStatus == NULL) { + HDF_LOGE("%{public}s halStatus is NULL", __func__); + return; + } + status->id = halStatus->id; + status->freq = halStatus->freq; + if (strcmp(halStatus->keyMgmt, "") != 0) { + HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); + status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); + if (status->keyMgmt == NULL) { + HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); + status->keyMgmtLen = 0; + return; + } + status->keyMgmtLen = strlen(halStatus->keyMgmt); + if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } + if (strcmp(halStatus->ssid, "") != 0) { + HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); + status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); + if (status->ssid == NULL) { + HDF_LOGE("%{public}s status->ssid is NULL", __func__); + status->ssidLen = 0; + return; + } + status->ssidLen = strlen(halStatus->ssid); + if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } + if (strcmp(halStatus->address, "") != 0) { + HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); + uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->address, tmpAddress); + status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->address == NULL) { + HDF_LOGE("%{public}s status->address is NULL", __func__); + status->addressLen = 0; + return; + } + status->addressLen = ETH_ADDR_LEN + 1 ; + if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { + HDF_LOGE("%{public}s strcpy memcpy", __func__); + } + } + if (strcmp(halStatus->bssid, "") != 0) { + HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); + uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->bssid, tmpBssid); + status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->bssid == NULL) { + HDF_LOGE("%{public}s status->bssid is NULL", __func__); + status->bssidLen = 0; + return; + } + status->bssidLen = ETH_ADDR_LEN + 1 ; + if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } +} + +int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) +{ + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL || status == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaHalCmdStatus halStatus; + if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { + pthread_mutex_unlock(&g_interfaceLock); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + status->bssidLen = 0; + status->ssidLen = 0; + status->keyMgmtLen = 0; + status->addressLen = 0; + WpaProcessWifiStatus(&halStatus, status); + if (status->addressLen == 0) { + HDF_LOGE("%{public}s key not include address", __func__); + } + if (status->bssidLen == 0) { + HDF_LOGE("%{public}s key not include bssid", __func__); + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +const char *macToStr(const u8 *addr) +{ + const int macAddrIndexOne = 0; + const int macAddrIndexTwo = 1; + const int macAddrIndexThree = 2; + const int macAddrIndexFour = 3; + const int macAddrIndexFive = 4; + const int macAddrIndexSix = 5; + static char macToStr[WIFI_BSSID_LENGTH]; + if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", + addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], + addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { + return NULL; + } + return macToStr; +} + +int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret; + if (wpaParam->anyFlag < 0 && wpaParam->multiAp <= 0 && wpaParam->bssidLen == 0) { + ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, NULL); + } else { + struct WpaWpsPbcArgv config = {0}; + config.anyFlag = wpaParam->anyFlag; + config.multiAp = wpaParam->multiAp; + if (wpaParam->bssidLen > 0) { + if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, + wpaParam->bssidLen) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); + return HDF_FAILURE; + } + } + ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); + } + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } else if (ret == WIFI_HAL_PBC_OVERLAP) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, + const struct HdiWifiWpsParam *wpaParam, int *pinCode) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL + || wpaParam->pinCode == NULL || pinCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaWpsPinArgv config = {{0}, {0}}; + if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), + strlen(macToStr(wpaParam->bssid))) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + + int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +//need to deal countryCodeLen +int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName, + char *countryCode, uint32_t countryCodeLen) +{ + HDF_LOGI("enter %{public}s: ", __func__); + (void)self; + if (ifName == NULL || countryCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +//need to deal valueLen +int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId, const char *param, char *value, uint32_t valueLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || param == NULL || value == NULL || valueLen == 0) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaGetNetworkArgv getNetwork = {0}; + getNetwork.id = networkId; + if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s param fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode) +{ + HDF_LOGI("enter %{public}s: mode = %{public}d", __func__, mode); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName, + struct ConnectionCapabilities *connectionCap) +{ + HDF_LOGI("enter %{public}s: ", __func__); + (void)self; + if (ifName == NULL || connectionCap == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || enable == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int scanSsid = 0; + int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + *enable = (scanSsid == 1); + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName, + char *psk, uint32_t pskLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || psk == NULL || pskLen == 0) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || psk == NULL || pskLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx, + uint8_t *wepKey, uint32_t *wepKeyLen) +{ + HDF_LOGI("enter %{public}s keyIdx = %{public}d", __func__, keyIdx); + (void)self; + if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || keyIdx == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || enable == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || countryCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) +{ + HDF_LOGI("enter %{public}s ", __func__); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); + return; + } + int ret = pWpaInterface->wpaCliTerminate(); + if (ret != 0) { + HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); + } else { + HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); + } + ReleaseWpaGlobalInterface(); + HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); +} + +static struct RemoteServiceDeathRecipient g_deathRecipient = { + .recipient = { + .OnRemoteDied = OnRemoteServiceDied, + } +}; + +static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) +{ + HDF_LOGI("enter %{public}s ", __func__); + if (cbFunc == NULL) { + HDF_LOGE("invalid parameter"); + return; + } + struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); + if (remote == NULL) { + HDF_LOGE("remote is NULL"); + return; + } + HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); +} + +static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + if (self == NULL) { + HDF_LOGE("%{public}s:self == NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!DListIsEmpty(head)) { + DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { + if (pos->service == self->AsObject(self)) { + HDF_LOGE("%{public}s: pos->service == self", __func__); + return HDF_FAILURE; + } + } + } + struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); + if (newRemoteNode == NULL) { + HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); + return HDF_FAILURE; + } + newRemoteNode->callbackObj = self; + newRemoteNode->service = self->AsObject(self); + DListInsertTail(&newRemoteNode->node, head); + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + AddDeathRecipientForService(self); + } + return HDF_SUCCESS; +} \ No newline at end of file -- Gitee From d63bc17ddcf29b18645b2d82aced87955847db72 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:33:16 +0000 Subject: [PATCH 0281/1485] update wlan/wpa/interfaces/hdi_service/service_common/test2.c. Signed-off-by: xionglei --- .../hdi_service/service_common/test2.c | 1065 +++++++++++++++++ 1 file changed, 1065 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test2.c b/wlan/wpa/interfaces/hdi_service/service_common/test2.c index e69de29bb2..5604e93f0f 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/test2.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/test2.c @@ -0,0 +1,1065 @@ +static void HdfWpaDelRemoteObj(struct IWpaCallback *self) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct HdfWpaRemoteNode *tmp = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { + if (pos->service->index == self->AsObject(self)->index) { + DListRemove(&(pos->node)); + IWpaCallbackRelease(pos->callbackObj); + OsalMemFree(pos); + pos = NULL; + break; + } + } + IWpaCallbackRelease(self); +} + +static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { + HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; + hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; + if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, + disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaDisconnectParam->bssid != NULL) { + OsalMemFree(hdiWpaDisconnectParam->bssid); + hdiWpaDisconnectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, + struct HdiWpaConnectParam *hdiWpaConnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (connectParam == NULL || hdiWpaConnectParam == NULL) { + HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaConnectParam->networkId = connectParam->networkId; + if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, + connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaConnectParam->bssid != NULL) { + OsalMemFree(hdiWpaConnectParam->bssid); + hdiWpaConnectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) +{ + int32_t ret = HDF_SUCCESS; + + if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { + HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, + bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, + bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill reason fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaBssidChangedParam->bssid != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->bssid); + hdiWpaBssidChangedParam->bssid = NULL; + } + if (hdiWpaBssidChangedParam->reason != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->reason); + hdiWpaBssidChangedParam->reason = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam, + struct HdiWpaStateChangedParam *hdiWpaStateChangedParam) +{ + int32_t ret = HDF_SUCCESS; + + if (stateChangedParam == NULL || hdiWpaStateChangedParam == NULL) { + HDF_LOGE("%{public}s: stateChangedParam or hdiWpaStateChangedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaStateChangedParam->networkId = stateChangedParam->networkId; + HDF_LOGD("%{public}s: hdiWpaStateChangedParam->networkId =%d", __func__, hdiWpaStateChangedParam->networkId); + hdiWpaStateChangedParam->status = stateChangedParam->status; + HDF_LOGD("%{public}s: hdiWpaStateChangedParam->status =%d", __func__, hdiWpaStateChangedParam->status); + do { + HDF_LOGD("%{public}s: stateChangedParam->bssid[0] = %x", __func__, stateChangedParam->bssid[0]); + HDF_LOGD("%{public}s: stateChangedParam->bssid[5] = %x", __func__, + stateChangedParam->bssid[WIFI_BSSID_LEN - 1]); + if (FillData(&hdiWpaStateChangedParam->bssid, &hdiWpaStateChangedParam->bssidLen, + stateChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + HDF_LOGD("%{public}s: stateChangedParam->ssid[0] = %x", __func__, stateChangedParam->ssid[0]); + HDF_LOGD("%{public}s: stateChangedParam->ssid[WIFI_SSID_LENGTH-1] = %x", __func__, + stateChangedParam->ssid[WIFI_SSID_LENGTH - 1]); + if (memcmp(stateChangedParam->ssid, "\0", 1) == 0) { + hdiWpaStateChangedParam->ssidLen = 0; + HDF_LOGE("%{public}s: hdiWpaStateChangedParam->ssidLen =%d", __func__, hdiWpaStateChangedParam->ssidLen); + } else { + if (FillData(&hdiWpaStateChangedParam->ssid, &hdiWpaStateChangedParam->ssidLen, + stateChangedParam->ssid, strlen((char*)stateChangedParam->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaStateChangedParam->bssid != NULL) { + OsalMemFree(hdiWpaStateChangedParam->bssid); + hdiWpaStateChangedParam->bssid = NULL; + } + if (hdiWpaStateChangedParam->ssid != NULL) { + OsalMemFree(hdiWpaStateChangedParam->ssid); + hdiWpaStateChangedParam->ssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam *tempDisabledParam, + struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam) +{ + int32_t ret = HDF_SUCCESS; + + if (tempDisabledParam == NULL || hdiWpaTempDisabledParam == NULL) { + HDF_LOGE("%{public}s: tempDisabledParam or hdiWpaTempDisabledParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaTempDisabledParam->networkId = tempDisabledParam->networkId; + hdiWpaTempDisabledParam->authFailures = tempDisabledParam->authFailures; + hdiWpaTempDisabledParam->duration = tempDisabledParam->duration; + do { + if (FillData(&hdiWpaTempDisabledParam->reason, &hdiWpaTempDisabledParam->reasonLen, + tempDisabledParam->reason, strlen((char*)tempDisabledParam->reason)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWpaTempDisabledParam->ssid, &hdiWpaTempDisabledParam->ssidLen, + tempDisabledParam->ssid, strlen((char*)tempDisabledParam->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaTempDisabledParam->reason != NULL) { + OsalMemFree(hdiWpaTempDisabledParam->reason); + hdiWpaTempDisabledParam->reason = NULL; + } + if (hdiWpaTempDisabledParam->ssid != NULL) { + OsalMemFree(hdiWpaTempDisabledParam->ssid); + hdiWpaTempDisabledParam->ssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam *associateRejectParam, + struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (associateRejectParam == NULL || hdiWpaAssociateRejectParam == NULL) { + HDF_LOGE("%{public}s: associateRejectParam or hdiWpaAssociateRejectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaAssociateRejectParam->statusCode = associateRejectParam->statusCode; + hdiWpaAssociateRejectParam->timeOut = associateRejectParam->timeOut; + if (FillData(&hdiWpaAssociateRejectParam->bssid, &hdiWpaAssociateRejectParam->bssidLen, + associateRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaAssociateRejectParam->bssid != NULL) { + OsalMemFree(hdiWpaAssociateRejectParam->bssid); + hdiWpaAssociateRejectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam *recvScanResultParam, + struct HdiWpaRecvScanResultParam *hdiWpaRecvScanResultParam) +{ + int32_t ret = HDF_SUCCESS; + + if (recvScanResultParam == NULL || hdiWpaRecvScanResultParam == NULL) { + HDF_LOGE("%{public}s: recvScanResultParam or hdiWpaRecvScanResultParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaRecvScanResultParam->scanId = recvScanResultParam->scanId; + return ret; +} + +static int32_t WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam *authRejectParam, + struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (authRejectParam == NULL || hdiWpaAuthRejectParam == NULL) { + HDF_LOGE("%{public}s: authRejectParam or hdiWpaAuthRejectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaAuthRejectParam->statusCode = authRejectParam->statusCode; + hdiWpaAuthRejectParam->authType = authRejectParam->authType; + hdiWpaAuthRejectParam->authTransaction = authRejectParam->authTransaction; + if (FillData(&hdiWpaAuthRejectParam->bssid, &hdiWpaAuthRejectParam->bssidLen, + authRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaAuthRejectParam->bssid != NULL) { + OsalMemFree(hdiWpaAuthRejectParam->bssid); + hdiWpaAuthRejectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t ProcessEventWpaDisconnect(struct HdfWpaRemoteNode *node, + struct WpaDisconnectParam *disconnectParam, const char *ifName) +{ + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDisconnected == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaDisconnectParam = (struct HdiWpaDisconnectParam *)OsalMemCalloc(sizeof(struct HdiWpaDisconnectParam)); + if ((hdiWpaDisconnectParam == NULL) || (WpaFillWpaDisconnectParam(disconnectParam, + hdiWpaDisconnectParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaDisconnectParam is NULL or disconnectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventDisconnected(node->callbackObj, hdiWpaDisconnectParam, ifName); + } + HdiWpaDisconnectParamFree(hdiWpaDisconnectParam, true); + return ret; +} + +static int32_t ProcessEventWpaConnect(struct HdfWpaRemoteNode *node, + struct WpaConnectParam *connectParam, const char *ifName) +{ + struct HdiWpaConnectParam *hdiWpaConnectParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventConnected == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaConnectParam = (struct HdiWpaConnectParam *)OsalMemCalloc(sizeof(struct HdiWpaConnectParam)); + if ((hdiWpaConnectParam == NULL) || (WpaFillWpaConnectParam(connectParam, hdiWpaConnectParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: HdiWpaConnectParam is NULL or connectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventConnected(node->callbackObj, hdiWpaConnectParam, ifName); + } + HdiWpaConnectParamFree(hdiWpaConnectParam, true); + return ret; +} + +static int32_t ProcessEventWpaBssidChange(struct HdfWpaRemoteNode *node, + struct WpaBssidChangedParam *bssidChangeParam, const char *ifName) +{ + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam = NULL; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventBssidChanged == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaBssidChangedParam = (struct HdiWpaBssidChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaBssidChangedParam)); + if ((hdiWpaBssidChangedParam == NULL) || (WpaFillWpaBssidChangedParam(bssidChangeParam, + hdiWpaBssidChangedParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaBssidChangedParam is NULL or bssidChangeParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventBssidChanged(node->callbackObj, hdiWpaBssidChangedParam, ifName); + } + HdiWpaBssidChangedParamFree(hdiWpaBssidChangedParam, true); + return ret; +} + +static int32_t ProcessEventWpaStateChange(struct HdfWpaRemoteNode *node, + struct WpaStateChangedParam *stateChangeParam, const char *ifName) +{ + struct HdiWpaStateChangedParam *hdiWpaStateChangedParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStateChanged == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaStateChangedParam = (struct HdiWpaStateChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaStateChangedParam)); + if ((hdiWpaStateChangedParam == NULL) || (WpaFillWpaStateChangedParam(stateChangeParam, + hdiWpaStateChangedParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaStateChangedParam is NULL or stateChangeParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventStateChanged(node->callbackObj, hdiWpaStateChangedParam, ifName); + } + HdiWpaStateChangedParamFree(hdiWpaStateChangedParam, true); + return ret; +} + +static int32_t ProcessEventWpaTempDisable(struct HdfWpaRemoteNode *node, + struct WpaTempDisabledParam *tempDisabledParam, const char *ifName) +{ + struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventTempDisabled == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaTempDisabledParam = (struct HdiWpaTempDisabledParam *)OsalMemCalloc(sizeof(struct HdiWpaTempDisabledParam)); + if ((hdiWpaTempDisabledParam == NULL) || (WpaFillWpaTempDisabledParam(tempDisabledParam, + hdiWpaTempDisabledParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaTempDisabledParam is NULL or tempDisabledParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventTempDisabled(node->callbackObj, hdiWpaTempDisabledParam, ifName); + } + HdiWpaTempDisabledParamFree(hdiWpaTempDisabledParam, true); + return ret; +} + +static int32_t ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode *node, + struct WpaAssociateRejectParam *associateRejectParam, const char *ifName) +{ + struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAssociateReject == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaAssociateRejectParam = (struct HdiWpaAssociateRejectParam *) + OsalMemCalloc(sizeof(struct HdiWpaAssociateRejectParam)); + if ((hdiWpaAssociateRejectParam == NULL) || (WpaFillWpaAssociateRejectParam(associateRejectParam, + hdiWpaAssociateRejectParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventAssociateReject(node->callbackObj, hdiWpaAssociateRejectParam, ifName); + } + HdiWpaAssociateRejectParamFree(hdiWpaAssociateRejectParam, true); + return ret; +} + +static int32_t ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode *node, + const char *ifName) +{ + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = node->callbackObj->OnEventWpsOverlap(node->callbackObj, ifName); + return ret; +} + +static int32_t ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode *node, + const char *ifName) +{ + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = node->callbackObj->OnEventWpsTimeout(node->callbackObj, ifName); + return ret; +} + +static int32_t ProcessEventWpaAuthTimeout(struct HdfWpaRemoteNode *node, const char *ifName) +{ + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = node->callbackObj->OnEventAuthTimeout(node->callbackObj, ifName); + return ret; +} + +static int32_t ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode *node, + struct WpaRecvScanResultParam *recvScanResultParam, const char *ifName) +{ + struct HdiWpaRecvScanResultParam *hdiRecvScanResultParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventScanResult == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiRecvScanResultParam = (struct HdiWpaRecvScanResultParam *) + OsalMemCalloc(sizeof(struct HdiWpaRecvScanResultParam)); + if ((hdiRecvScanResultParam == NULL) || (WpaFillWpaRecvScanResultParam(recvScanResultParam, + hdiRecvScanResultParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventScanResult(node->callbackObj, hdiRecvScanResultParam, ifName); + } + HdiWpaRecvScanResultParamFree(hdiRecvScanResultParam, true); + return ret; +} + +static int32_t ProcessEventWpaAuthReject( + struct HdfWpaRemoteNode *node, struct WpaAuthRejectParam *authRejectParam, const char *ifName) +{ + struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam = NULL; + int32_t ret = HDF_FAILURE; + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAuthReject == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaAuthRejectParam = + (struct HdiWpaAuthRejectParam *)OsalMemCalloc(sizeof(struct HdiWpaAuthRejectParam)); + if ((hdiWpaAuthRejectParam == NULL) || + (WpaFillWpaAuthRejectParam(authRejectParam, hdiWpaAuthRejectParam) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiWpaAuthRejectParam is NULL or authRejectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventAuthReject(node->callbackObj, hdiWpaAuthRejectParam, ifName); + } + HdiWpaAuthRejectParamFree(hdiWpaAuthRejectParam, true); + return ret; +} + +int32_t ProcessEventStaNotify(struct HdfWpaRemoteNode *node, char *notifyParam, const char *ifName) +{ + int32_t ret = HDF_FAILURE; + if (notifyParam == NULL || ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_FAILURE; + } + char *notifyStr = (char*)malloc(BUF_SIZE); + if (notifyStr == NULL) { + HDF_LOGE("%{public}s notifyStr malloc failed", __func__); + return HDF_FAILURE; + } + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaNotify == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + free(notifyStr); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(notifyStr, BUF_SIZE, 0, BUF_SIZE) != EOK) { + HDF_LOGE("%{public}s memset failed", __func__); + free(notifyStr); + return HDF_FAILURE; + } + if (strcpy_s(notifyStr, BUF_SIZE, notifyParam) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + free(notifyStr); + return HDF_FAILURE; + } + ret = node->callbackObj->OnEventStaNotify(node->callbackObj, notifyStr, ifName); + free(notifyStr); + return ret; +} + +static int32_t WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo *wpaVendorExtInfo, + struct WpaVendorInfo *wpaVendorInfo) +{ + if (wpaVendorExtInfo == NULL || wpaVendorInfo == NULL) { + HDF_LOGE("%{public}s: wpaVendorExtInfo or wpaVendorInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + wpaVendorInfo->type = wpaVendorExtInfo->type; + wpaVendorInfo->freq = wpaVendorExtInfo->freq; + wpaVendorInfo->width = wpaVendorExtInfo->width; + wpaVendorInfo->id = wpaVendorExtInfo->id; + wpaVendorInfo->status = wpaVendorExtInfo->status; + wpaVendorInfo->reason = wpaVendorExtInfo->reason; + if (FillData(&wpaVendorInfo->ssid, &wpaVendorInfo->ssidLen, + wpaVendorExtInfo->ssid, strlen((char *)wpaVendorExtInfo->ssid)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s ssid fail !", __func__); + return HDF_FAILURE; + } + + if (FillData(&wpaVendorInfo->psk, &wpaVendorInfo->pskLen, + wpaVendorExtInfo->psk, strlen((char *)wpaVendorExtInfo->psk)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s psk fail !", __func__); + return HDF_FAILURE; + } + + if (FillData(&wpaVendorInfo->devAddr, &wpaVendorInfo->devAddrLen, + wpaVendorExtInfo->devAddr, ETH_ADDR_LEN) != EOK) { + HDF_LOGE("%{public}s: memcpy_s devAddr fail !", __func__); + return HDF_FAILURE; + } + + if (FillData(&wpaVendorInfo->data, &wpaVendorInfo->dataLen, + wpaVendorExtInfo->data, strlen((char *)wpaVendorExtInfo->data)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s data fail !", __func__); + return HDF_FAILURE; + } + + HDF_LOGI("wpaVendorInfo type %{public}d, freq %{public}d, reason %{public}d, " + "id %{public}d status %{public}d!", + wpaVendorInfo->type, wpaVendorInfo->freq, wpaVendorInfo->reason, + wpaVendorInfo->id, wpaVendorInfo->status); + return HDF_SUCCESS; +} + +static int32_t ProcessEventWpaVendorExt(struct HdfWpaRemoteNode *node, + struct WpaVendorExtInfo *wpaVendorExtInfo, const char *ifName) +{ + HDF_LOGI("%{public}s: ifName => %{public}s ; ", __func__, ifName); + struct WpaVendorInfo wpaVendorInfo; + int32_t ret = HDF_FAILURE; + if (wpaVendorExtInfo == NULL) { + HDF_LOGE("%{public}s: wpaVendorExtInfo is NULL !", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventVendorCb == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (WpaFillWpaVendorExtInfo(wpaVendorExtInfo, &wpaVendorInfo) != HDF_SUCCESS) { + ret = HDF_FAILURE; + HDF_LOGE("%{public}s: wpaVendorInfo is NULL or associateRejectParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventVendorCb(node->callbackObj, &wpaVendorInfo, ifName); + } + HDF_LOGI("%{public}s: res %{public}d!", __func__, ret); + return ret; +} +static int32_t HdfStaDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) +{ + int32_t ret = HDF_FAILURE; + switch (event) { + case WPA_EVENT_DISCONNECT: + ret = ProcessEventWpaDisconnect(pos, (struct WpaDisconnectParam *)data, ifName); + break; + case WPA_EVENT_CONNECT: + ret = ProcessEventWpaConnect(pos, (struct WpaConnectParam *)data, ifName); + break; + case WPA_EVENT_BSSID_CHANGE: + ret = ProcessEventWpaBssidChange(pos, (struct WpaBssidChangedParam *)data, ifName); + break; + case WPA_EVENT_STATE_CHANGED: + ret = ProcessEventWpaStateChange(pos, (struct WpaStateChangedParam *)data, ifName); + break; + case WPA_EVENT_TEMP_DISABLE: + ret = ProcessEventWpaTempDisable(pos, (struct WpaTempDisabledParam *)data, ifName); + break; + case WPA_EVENT_ASSOCIATE_REJECT: + ret = ProcessEventWpaAssociateReject(pos, (struct WpaAssociateRejectParam *)data, ifName); + break; + case WPA_EVENT_WPS_OVERLAP: + ret = ProcessEventWpaWpsOverlap(pos, ifName); + break; + case WPA_EVENT_WPS_TIMEMOUT: + ret = ProcessEventWpaWpsTimeout(pos, ifName); + break; + case WPA_EVENT_AUTH_TIMEOUT: + ProcessEventWpaAuthTimeout(pos, ifName); + break; + case WPA_EVENT_RECV_SCAN_RESULT: + ret = ProcessEventWpaRecvScanResult(pos, (struct WpaRecvScanResultParam *)data, ifName); + break; + case WPA_EVENT_STA_AUTH_REJECT: + ret = ProcessEventWpaAuthReject(pos, (struct WpaAuthRejectParam *)data, ifName); + break; + case WPA_EVENT_STA_NOTIFY: + ret = ProcessEventStaNotify(pos, (char *)data, ifName); + break; + default: + HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); + break; + } + return ret; +} + +static int32_t HdfP2pDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) +{ + int32_t ret = HDF_FAILURE; + switch (event) { + case WPA_EVENT_DEVICE_FOUND: + ret = ProcessEventP2pDeviceFound(pos, (struct P2pDeviceInfoParam *)data, ifName); + break; + case WPA_EVENT_DEVICE_LOST: + ret = ProcessEventP2pDeviceLost(pos, (struct P2pDeviceLostParam *)data, ifName); + break; + case WPA_EVENT_GO_NEGOTIATION_REQUEST: + ret = ProcessEventP2pGoNegotiationRequest(pos, (struct P2pGoNegotiationRequestParam *)data, ifName); + break; + case WPA_EVENT_GO_NEGOTIATION_COMPLETED: + ret = ProcessEventP2pGoNegotiationCompleted(pos, (struct P2pGoNegotiationCompletedParam *)data, ifName); + break; + case WPA_EVENT_INVITATION_RECEIVED: + ret = ProcessEventP2pInvitationReceived(pos, (struct P2pInvitationReceivedParam *)data, ifName); + break; + case WPA_EVENT_INVITATION_RESULT: + ret = ProcessEventP2pInvitationResult(pos, (struct P2pInvitationResultParam *)data, ifName); + break; + case WPA_EVENT_GROUP_FORMATION_SUCCESS: + ret = ProcessEventP2pGroupFormationSuccess(pos, ifName); + break; + case WPA_EVENT_GROUP_FORMATION_FAILURE: + ret = ProcessEventP2pGroupFormationFailure(pos, (char *)data, ifName); + break; + case WPA_EVENT_GROUP_START: + ret = ProcessEventP2pGroupStarted(pos, (struct P2pGroupStartedParam *)data, ifName); + break; + case WPA_EVENT_GROUP_REMOVED: + ret = ProcessEventP2pGroupRemoved(pos, (struct P2pGroupRemovedParam *)data, ifName); + break; + case WPA_EVENT_PROVISION_DISCOVERY_COMPLETED: + ret = ProcessEventP2pProvisionDiscoveryCompleted(pos, (struct P2pProvisionDiscoveryCompletedParam *)data, + ifName); + break; + case WPA_EVENT_FIND_STOPPED: + ret = ProcessEventP2pFindStopped(pos, ifName); + break; + case WPA_EVENT_SERV_DISC_REQ: + ret = ProcessEventP2pServDiscReq(pos, (struct P2pServDiscReqInfoParam *)data, ifName); + break; + case WPA_EVENT_SERV_DISC_RESP: + ret = ProcessEventP2pServDiscResp(pos, (struct P2pServDiscRespParam *)data, ifName); + break; + case WPA_EVENT_STA_CONNECT_STATE: + ret = ProcessEventP2pStaConnectState(pos, (struct P2pStaConnectStateParam *)data, ifName); + break; + case WPA_EVENT_IFACE_CREATED: + ret = ProcessEventP2pIfaceCreated(pos, (struct P2pIfaceCreatedParam *)data, ifName); + break; + case WPA_EVENT_STA_NOTIFY: + ret = ProcessEventStaNotify(pos, (char *)data, ifName); + break; + default: + HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); + break; + } + return ret; +} + +static int32_t HdfVendorExtDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) +{ + int32_t ret = HDF_FAILURE; + switch (event) { + case WPA_EVENT_VENDOR_EXT: + ret = ProcessEventWpaVendorExt(pos, (struct WpaVendorExtInfo *)data, ifName); + break; + default: + HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); + break; + } + return ret; +} + + +static int32_t HdfWpaCallbackFun(uint32_t event, void *data, const char *ifName) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct DListHead *head = NULL; + int32_t ret = HDF_FAILURE; + + (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); + head = &HdfWpaStubDriver()->remoteListHead; + HDF_LOGD("%s: enter HdfWpaCallbackFun event =%u", __FUNCTION__, event); + if (ifName == NULL) { + HDF_LOGE("%{public}s: data or ifName is NULL!", __func__); + (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); + return HDF_ERR_INVALID_PARAM; + } + DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { + if (pos == NULL) { + HDF_LOGE("%{public}s: pos is NULL", __func__); + break; + } + if (pos->callbackObj == NULL) { + HDF_LOGW("%{public}s: pos->callbackObj NULL", __func__); + continue; + } + if (pos->service == NULL) { + HDF_LOGW("%{public}s: pos->service NULL", __func__); + continue; + } + if (strncmp(ifName, "wlan", strlen("wlan")) == 0 || strncmp(ifName, "common", strlen("common")) == 0) { + ret = HdfStaDealEvent(event, pos, data, ifName); + } else if (strncmp(ifName, "chba", strlen("chba")) == 0 || + strncmp(ifName, "p2p-chba", strlen("p2p-chba")) == 0) { + ret = HdfVendorExtDealEvent(event, pos, data, ifName); + } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { + ret = HdfP2pDealEvent(event, pos, data, ifName); + } else { + HDF_LOGE("%{public}s: ifName is error %{public}s", __func__, ifName); + } + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: dispatch code fialed, error code: %{public}d", __func__, ret); + } + } + (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); + return ret; +} + +int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, + const char *ifName) +{ + int32_t ret = HDF_FAILURE; + + (void)self; + pthread_mutex_lock(&g_interfaceLock); + if (cbFunc == NULL || ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + int nameLen = strlen(ifName); + if (IsSockRemoved(ifName, nameLen) == 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("invalid opt"); + return HDF_FAILURE; + } + do { + HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); + ret = HdfWpaAddRemoteObj(cbFunc, ifName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: HdfSensorAddRemoteObj false", __func__); + break; + } + ret = WpaRegisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Register failed!, error code: %{public}d", __func__, ret); + HdfWpaDelRemoteObj(cbFunc); + break; + } + } while (0); + pthread_mutex_unlock(&g_interfaceLock); + return ret; +} + +int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, + const char *ifName) +{ + (void)self; + pthread_mutex_lock(&g_interfaceLock); + if (cbFunc == NULL || ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + int nameLen = strlen(ifName); + if (IsSockRemoved(ifName, nameLen) == 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("invalid opt"); + return HDF_FAILURE; + } + HdfWpaDelRemoteObj(cbFunc); + if (DListIsEmpty(&HdfWpaStubDriver()->remoteListHead)) { + int32_t ret = WpaUnregisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Unregister failed!, error code: %{public}d", __func__, ret); + } + } + pthread_mutex_unlock(&g_interfaceLock); + return HDF_SUCCESS; +} + +static void SplitCmdString(const char *startCmd, struct StWpaMainParam *pParam) +{ + if (pParam == NULL) { + return; + } + if (startCmd == NULL) { + pParam->argc = 0; + return; + } + const char *p = startCmd; + int i = 0; + int j = 0; + while (*p != '\0') { + if (*p == ' ') { + if (j <= MAX_WPA_MAIN_ARGV_LEN - 1) { + pParam->argv[i][j] = '\0'; + } else { + pParam->argv[i][MAX_WPA_MAIN_ARGV_LEN - 1] = '\0'; + } + ++i; + j = 0; + if (i >= MAX_WPA_MAIN_ARGC_NUM) { + break; + } + } else { + if (j < MAX_WPA_MAIN_ARGV_LEN - 1) { + pParam->argv[i][j] = *p; + ++j; + } + } + ++p; + } + if (i >= MAX_WPA_MAIN_ARGC_NUM) { + pParam->argc = MAX_WPA_MAIN_ARGC_NUM; + } else { + pParam->argc = i + 1; + } + return; +} + + +static void *WpaThreadMain(void *p) +{ + const char *startCmd; + struct StWpaMainParam param = {0}; + char *tmpArgv[MAX_WPA_MAIN_ARGC_NUM] = {0}; + + if (p == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return NULL; + } + startCmd = (const char *)p; + SplitCmdString(startCmd, ¶m); + for (int i = 0; i < param.argc; i++) { + tmpArgv[i] = param.argv[i]; + } + int ret = wpa_main(param.argc, tmpArgv); + HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret); + return NULL; +} + +static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) +{ + int32_t ret; + + if (moduleName == NULL || startCmd == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_setname_np(g_tid, "WpaMainThread"); + HDF_LOGI("%{public}s: pthread_create successfully.", __func__); + usleep(WPA_SLEEP_TIME); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + return HDF_FAILURE; + } + if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { + HDF_LOGE("Failed to connect to wpa!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) +{ + (void)self; + if (ifName == NULL || confName == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + HDF_LOGI("enter %{public}s Ready to add iface, ifName: %{public}s, confName: %{public}s", + __func__, ifName, confName); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + return HDF_FAILURE; + } + AddInterfaceArgv addInterface = {0}; + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/wpa_supplicant.conf") != EOK) { + return HDF_FAILURE; + } + } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { + return HDF_FAILURE; + } + } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { + return HDF_FAILURE; + } + } else { + HDF_LOGE("%{public}s Wrong ifname!", __func__); + return HDF_FAILURE; + } + if (pWpaInterface->wpaCliAddIface(pWpaInterface, &addInterface, true) < 0) { + HDF_LOGE("%{public}s Failed to add wpa iface!", __func__); + return HDF_FAILURE; + } + HDF_LOGI("%{public}s Add interface finish", __func__); + return HDF_SUCCESS; +} + + +int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); + if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + HDF_LOGI("enter %{public}s Ready to Remove iface, ifName: %{public}s", __func__, ifName); + int ret = -1; + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + return HDF_FAILURE; + } + ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); + return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); +} + +static int32_t StopWpaSupplicant(void) +{ + /*Do nothing here,waiting for IWpaInterfaceReleaseInstance to destroy the wpa service. */ + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); + return HDF_FAILURE; + } + int ret = pWpaInterface->wpaCliTerminate(); + if (ret != 0) { + HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); + } else { + HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); + } + return HDF_SUCCESS; +} + +int32_t WpaInterfaceStart(struct IWpaInterface *self) +{ + int32_t ret; + + (void)self; + HDF_LOGI("enter %{public}s: wpa_supplicant begin to start", __func__); + InitWifiWpaGlobalInterface(); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGI("fail get global interface"); + return HDF_FAILURE; + } + pthread_mutex_lock(&g_interfaceLock); + ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(&g_interfaceLock); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceStop(struct IWpaInterface *self) +{ + int32_t ret; + + (void)self; + pthread_mutex_lock(&g_interfaceLock); + HDF_LOGI("enter %{public}s: wpa_supplicant begin to stop", __func__); + ret = StopWpaSupplicant(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(&g_interfaceLock); + return HDF_FAILURE; + } + ReleaseWifiStaInterface(0); + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + pthread_mutex_lock(&g_interfaceLock); + if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdReassociate(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdReassociate fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdReassociate success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); + if (ifName == NULL || cmd == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdStaShellCmd(pStaIfc, cmd); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: fail ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: success", __func__); + return HDF_SUCCESS; +} -- Gitee From 58930437dd59fc846162a424a29a2b412d8418c5 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:34:47 +0000 Subject: [PATCH 0282/1485] update wlan/wpa/interfaces/hdi_service/service_common/test3.c. Signed-off-by: xionglei --- .../hdi_service/service_common/test3.c | 1239 +++++++++++++++++ 1 file changed, 1239 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test3.c b/wlan/wpa/interfaces/hdi_service/service_common/test3.c index e69de29bb2..8f7f249411 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/test3.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/test3.c @@ -0,0 +1,1239 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "wpa_common_cmd.h" +#include "wpa_p2p_cmd.h" +#include "hdi_wpa_common.h" +#include +#include +#include +#include +#include +#include +#include "utils/common.h" +#include "wpa_supplicant_i.h" +#include "main.h" +#include "wps_supplicant.h" +#include "p2p_supplicant.h" +#include "ctrl_iface.h" +#include "wpa_magiclink.h" +#include "wifi_display.h" +#include "bssid_ignore.h" +#include "config.h" +#include "v1_1/iwpa_callback.h" +#include "v1_1/iwpa_interface.h" +#include "wpa_p2p_hal.h" + +#define HEX_TO_DEC_MOVING 4 +#define DEC_MAX_SCOPE 10 +#define MIN_MAC_LEN 6 + +struct HdiWpaKeyValue { + char key[CMD_SIZE]; + char value[CMD_SIZE]; +}; + +void GetStrKeyVal(char *src, const char *split, struct HdiWpaKeyValue *out) +{ + if (src == NULL || split == NULL || out == NULL) { + return; + } + char *p = strstr(src, split); + if (p == NULL) { + if (strcpy_s(out->key, sizeof(out->key), src) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + return; + } + *p = '\0'; + if (strcpy_s(out->key, sizeof(out->key), src) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + p += strlen(split); + if (strcpy_s(out->value, sizeof(out->value), p) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + return; +} + +void GetHalNetworkInfos(char *buf, struct HdiP2pNetworkInfo *info) +{ + if (buf == NULL || info == NULL) { + return; + } + int len = strlen(buf); + int start = 0; + int end = 0; + int i = 0; + const int count = 2; + while (end < len) { + if (buf[end] != '\t') { + ++end; + continue; + } + buf[end] = '\0'; + if (i == 0) { + info->id = atoi(buf); + } else if (i == 1) { + if (strcpy_s((char *)info->ssid, WIFI_SSID_LENGTH + 1, buf + start) != EOK) { + break; + } + printf_decode((u8 *)info->ssid, WIFI_SSID_LENGTH + 1, (char *)info->ssid); + } else if (i == count) { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(buf + start, tmpBssid); + if (strcpy_s((char *)info->bssid, ETH_ADDR_LEN + 1, (char *)tmpBssid) != EOK) { + break; + } + start = end + 1; + if (strcpy_s((char *)info->flags, WIFI_NETWORK_FLAGS_LENGTH + 1, buf + start) != EOK) { + break; + } + break; + } + ++i; + end++; + start = end; + } + return; +} + +int32_t WpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface *self, const char *ifName, const char *name) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || name == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetSsidPostfixName(pMainIfc, name); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface *self, const char *ifName, const char *type) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || type == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsDeviceType(pMainIfc, type); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface *self, const char *ifName, const char *methods) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || methods == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsConfigMethods(pMainIfc, methods); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface *self, const char *ifName, int32_t time) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); + if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pGroupIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetGroupIdle(pGroupIfc, time); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetWfdEnable(struct IWpaInterface *self, const char *ifName, int32_t enable) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdEnable(pMainIfc, enable); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface *self, const char *ifName, int32_t status) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetPersistentReconnect(pMainIfc, status); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface *self, const char *ifName, const char *type) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || type == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsSecDeviceType(pMainIfc, type); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetupWpsPbc(struct IWpaInterface *self, const char *ifName, const char *address) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || address == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); + if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pGroupIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPbc(pGroupIfc, address); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetupWpsPin(struct IWpaInterface *self, const char *ifName, const char *address, + const char *pin, char *result, uint32_t resultLen) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || address == NULL || pin == NULL || result == NULL || resultLen == 0) { + HDF_LOGE("%{public}s groupIfc, address, pin and result have NULL", __func__); + return HDF_FAILURE; + } + + P2pWpsPinDisplayArgv p2pWpsPinDisplay = {0}; + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); + if (pMainIfc == NULL || pGroupIfc == NULL) { + HDF_LOGE("%{public}s: pMainIfc or pGroupIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPin(pGroupIfc, &p2pWpsPinDisplay); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + HDF_LOGE("WpaP2pCliCmdWpsPin fail, ret = %{public}d", ret); + return HDF_FAILURE; + } + if (strlen(pin) > 0) { + p2pWpsPinDisplay.mode = P2P_PIN_KEYPAD; + if (strncpy_s(p2pWpsPinDisplay.pinCode, sizeof(p2pWpsPinDisplay.pinCode), pin, strlen(pin)) != EOK) { + HDF_LOGE("%{public}s: Failed to init pin code, the input pin code may be invalid!", __func__); + return HDF_FAILURE; + } + } else { + p2pWpsPinDisplay.mode = P2P_PIN_DISPLAY; + if ((strncpy_s(p2pWpsPinDisplay.bssid, sizeof(p2pWpsPinDisplay.bssid), address, strlen(address)) != EOK) || + (strncpy_s(result, resultLen, p2pWpsPinDisplay.pinCode, strlen(p2pWpsPinDisplay.pinCode)) != EOK)) { + HDF_LOGE("%{public}s: Failed to init request message, the input message may be invalid!", __func__); + return HDF_FAILURE; + } + } + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetPowerSave(struct IWpaInterface *self, const char *ifName, int32_t enable) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("P2pSetPowerSave, groupIfc is NULL"); + return HDF_FAILURE; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); + if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pGroupIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetPowerSave(pGroupIfc, enable); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetDeviceName(struct IWpaInterface *self, const char *ifName, const char *name) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || name == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsName(pMainIfc, name); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface *self, const char *ifName, const char *config) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || config == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdDeviceInfo(pMainIfc, config); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetRandomMac(struct IWpaInterface *self, const char *ifName, int32_t networkId) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetRandomMac(pMainIfc, networkId); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pStartFind(struct IWpaInterface *self, const char *ifName, int32_t timeout) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pFound(pMainIfc, timeout); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetExtListen(struct IWpaInterface *self, const char *ifName, int32_t enable, + int32_t period, int32_t interval) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdExtListen(pMainIfc, enable, period, interval); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetListenChannel(struct IWpaInterface *self, const char *ifName, + int32_t channel, int32_t regClass) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetListenChannel(pMainIfc, channel, regClass); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pProvisionDiscovery(struct IWpaInterface *self, const char *ifName, + const char *peerBssid, int32_t mode) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || peerBssid == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + P2pProvisionDiscoveryArgv p2pProvision; + if (memset_s(&p2pProvision, sizeof(p2pProvision), 0, sizeof(p2pProvision)) != EOK || + strncpy_s(p2pProvision.peerbssid, sizeof(p2pProvision.peerbssid), peerBssid, strlen(peerBssid)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("Failed to init request message, the input message may be invalid!"); + return HDF_FAILURE; + } + p2pProvision.mode = mode; + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdProvisionDiscovery(pMainIfc, &p2pProvision); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pAddGroup(struct IWpaInterface *self, const char *ifName, int32_t isPersistent, + int32_t networkId, int32_t freq) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGroupAdd(pMainIfc, isPersistent, networkId, freq); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pAddService(struct IWpaInterface *self, const char *ifName, + const struct HdiP2pServiceInfo *info) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || info == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceAdd(pMainIfc, info); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pRemoveService(struct IWpaInterface *self, const char *ifName, + const struct HdiP2pServiceInfo *info) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || info == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceDel(pMainIfc, info); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pStopFind(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pStopFind(pMainIfc); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pFlush(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlush(pMainIfc); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pFlushService(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlushService(pMainIfc); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRemoveNetwork(pMainIfc, networkId); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId, + const char *name, const char *value) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + char cmd[CMD_SIZE] = {0}; + char buf[CMD_SIZE] = {0}; + int32_t ret = 0; + (void)self; + if (ifName == NULL || name == NULL || value == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET_NETWORK %d %s %s", + ifName, networkId, name, value); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + return HDF_FAILURE; + } + if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s command failed!", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pInvite(struct IWpaInterface *self, const char *ifName, + const char *peerBssid, const char *goBssid) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (peerBssid == NULL || goBssid == NULL || ifName == NULL) { + HDF_LOGE("%{public}s: peerBssid, goBssid and ifname have NULL", __func__); + return HDF_FAILURE; + } + pthread_mutex_lock(GetInterfaceLock()); + P2pHalInviteArgv p2pHalInvite; + if (memset_s(&p2pHalInvite, sizeof(p2pHalInvite), 0, sizeof(p2pHalInvite)) != EOK || + strncpy_s(p2pHalInvite.peerbssid, sizeof(p2pHalInvite.peerbssid), peerBssid, strlen(peerBssid)) != EOK || + strncpy_s(p2pHalInvite.gobssid, sizeof(p2pHalInvite.gobssid), goBssid, strlen(goBssid)) != EOK || + strncpy_s(p2pHalInvite.ifname, sizeof(p2pHalInvite.ifname), ifName, strlen(ifName)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("Failed to init request message, the input message may be invalid!"); + return HDF_FAILURE; + } + p2pHalInvite.persistent = 0; + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdInvite(pMainIfc, &p2pHalInvite); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pReinvoke(struct IWpaInterface *self, const char *ifName, const int32_t networkId, + const char *bssid) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || bssid == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + P2pHalReInviteArgv p2pHalReInvite; + if (memset_s(&p2pHalReInvite, sizeof(p2pHalReInvite), 0, sizeof(p2pHalReInvite)) != EOK || + strncpy_s(p2pHalReInvite.peerbssid, sizeof(p2pHalReInvite.peerbssid), bssid, strlen(bssid)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("Failed to init request message, the input message may be invalid!"); + return HDF_FAILURE; + } + p2pHalReInvite.networkId = networkId; + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdReInvite(pMainIfc, &p2pHalReInvite); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pGetDeviceAddress(struct IWpaInterface *self, const char *ifName, char *deviceAddress, + uint32_t deviceAddressLen) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || deviceAddress == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + (void)self; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGetDeviceAddress(pMainIfc, deviceAddress, deviceAddressLen); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface *self, const char *ifName, + const struct HdiP2pReqService *reqService, char *replyDisc, uint32_t replyDiscLen) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || reqService == NULL || replyDisc == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + (void)self; + char seq[WIFI_P2P_SERVER_DISCOVERY_SEQUENCE_LENGTH] = {0}; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscReq(pMainIfc, (char *)reqService->bssid, + (char *)reqService->msg, seq, sizeof(seq)); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + if (strncpy_s(replyDisc, replyDiscLen, seq, strlen(seq)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface *self, const char *ifName, const char *id) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || id == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscCancelReq(pMainIfc, id); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pRespServerDiscovery(struct IWpaInterface *self, const char *ifName, + const struct HdiP2pServDiscReqInfo *info) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || info == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + (void)self; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRespServerDiscovery(pMainIfc, info); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("WpaP2pCliCmdRespServerDiscovery fail, ret = %{public}d", ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, const struct HdiP2pConnectInfo *info, + char *replyPin, uint32_t replyPinLen) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || info == NULL || replyPin == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + char *reply; + const int replySize = REPLY_SIZE; + char cmd[CMD_SIZE] = {0}; + char join[CMD_SIZE] = {0}; + char mode[CMD_SIZE] = {0}; + char pin[CMD_SIZE] = {0}; + char peerDevAddr[CMD_SIZE] = {0}; + if (memcpy_s(pin, CMD_SIZE, info->pin, CMD_SIZE) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s strcpy failed", __func__); + return HDF_FAILURE; + } + + if (memcpy_s(peerDevAddr, CMD_SIZE, info->peerDevAddr, CMD_SIZE) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s strcpy failed", __func__); + return HDF_FAILURE; + } + + reply = (char *)malloc(replySize); + if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is NULL!", __func__); + return HDF_FAILURE; + } + + int32_t ret = 0; + (void)self; + + if (info->mode != 0) { + if (strcpy_s(join, sizeof(join), " join") != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else { + if (snprintf_s(join, sizeof(join), sizeof(join) - 1, " go_intent=%d", info->goIntent) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s input parameter invalid!", __func__); + free(reply); + return HDF_ERR_INVALID_PARAM; + } + } + + if (info->provdisc == P2P_WPS_METHOD_DISPLAY) { + if (strcpy_s(mode, sizeof(mode), " display") != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else if (info->provdisc == P2P_WPS_METHOD_KEYPAD) { + if (strcpy_s(mode, sizeof(mode), " keypad") != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else if (info->provdisc == P2P_WPS_METHOD_PBC && info->pin != NULL && strlen((char *)info->pin) == 0) { + if (strcpy_s(pin, CMD_SIZE, "pbc") != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s Mode value is invalid %{public}d!", __func__, info->provdisc); + free(reply); + return HDF_ERR_INVALID_PARAM; + } + + char persistent[CMD_SIZE] = {0}; + if (info->peerDevAddr && strlen(peerDevAddr) >= MIN_MAC_LEN) { + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_CONNECT %s %s%s%s%s", ifName, + macToStr(info->peerDevAddr), pin, mode, persistent, join); + } + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + free(reply); + return HDF_FAILURE; + } + + if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("P2P_CONNECT command failed!"); + free(reply); + return HDF_FAILURE; + } + + if (strncmp(reply, "FAIL", strlen("FAIL")) == 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s P2p connect return %{public}s", __func__, reply); + free(reply); + return HDF_FAILURE; + } + if (info->provdisc == P2P_WPS_METHOD_DISPLAY && strcmp((char *)info->pin, "pin") == 0) { + if (strncpy_s(replyPin, replyPinLen, reply, strlen(reply)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s Failed to copy response pin code info!", __func__); + free(reply); + return HDF_FAILURE; + } + } + pthread_mutex_unlock(GetInterfaceLock()); + free(reply); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifName, + const struct HdiHid2dConnectInfo *info) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || info == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + char cmd[CMD_SIZE]; + char buf[CMD_SIZE]; + (void)self; + int freq = (info->frequency >> 16); + int isLegacyGo = (info->frequency & 0xffff); + if (freq < 0) { + HDF_LOGE("hid2dconnect freq is failed, freq=%{public}d", freq); + freq = 0; + } + HDF_LOGI("hid2dconnect freq=%{public}d, isLegacyGo=%{public}d", freq, isLegacyGo); + if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s MAGICLINK \"%s\"\n%s\n\"%s\"\n%d\n%d", ifName, + (char *)info->ssid, macToStr(info->bssid), (char *)info->passphrase, freq, isLegacyGo) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s.", __func__, cmd); + return HDF_FAILURE; + } + if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("hid2d_connect command failed!"); + return HDF_FAILURE; + } + if (strncmp(buf, "FAIL", strlen("FAIL")) == 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: return %{public}s", __func__, buf); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSetServDiscExternal(struct IWpaInterface *self, const char *ifName, int32_t mode) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetServDiscExternal(pMainIfc, mode); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("WpaP2pCliCmdSetServDiscExternal fail, ret = %{public}d", ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pRemoveGroup(struct IWpaInterface *self, const char *ifName, const char *groupName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + if (ifName == NULL || groupName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pRemoveGroup(pMainIfc, groupName); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pCancelConnect(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdCancelConnect(pMainIfc); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pGetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId, + const char *param, char *value, uint32_t valueLen) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + char cmd[CMD_SIZE]; + + int32_t ret = 0; + (void)self; + if (ifName == NULL || param == NULL || value == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s GET_NETWORK %d %s", ifName, networkId, param); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + return HDF_FAILURE; + } + if (WpaCliCmd(cmd, value, valueLen) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("GET_NETWORK command failed!"); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || networkId == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + (void)self; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdAddNetwork(pMainIfc, networkId); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("WpaP2pCliCmdAddNetwork fail, ret = %{public}d", ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} \ No newline at end of file -- Gitee From 7942de449b67120a07dff5fab18f7eea65e1ec34 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:35:59 +0000 Subject: [PATCH 0283/1485] update wlan/wpa/interfaces/hdi_service/service_common/test4.c. Signed-off-by: xionglei --- .../hdi_service/service_common/test4.c | 1177 +++++++++++++++++ 1 file changed, 1177 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test4.c b/wlan/wpa/interfaces/hdi_service/service_common/test4.c index e69de29bb2..5262e2b3c3 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/test4.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/test4.c @@ -0,0 +1,1177 @@ +int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, const char *bssid, + struct HdiP2pDeviceInfo *info) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || info == NULL || bssid == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + char *reply; + const int replySize = REPLY_SIZE; + char cmd[CMD_SIZE]; + + reply = (char *)malloc(replySize); + if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is NULL!", __func__); + return HDF_FAILURE; + } + + int32_t ret = 0; + (void)self; + + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + free(reply); + return HDF_FAILURE; + } + + if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("P2P_PEER command failed!"); + free(reply); + return HDF_FAILURE; + } + + if (strstr(reply, "\n") == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is error", __func__); + free(reply); + return HDF_FAILURE; + } + char *savedPtr = NULL; + char *token = strtok_r(reply, "\n", &savedPtr); + info->srcAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (info->srcAddress == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc srcAddress failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->p2pDeviceAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (info->p2pDeviceAddress == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc p2pDeviceAddress failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->primaryDeviceType = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_TYPE_LENGTH); + if (info->primaryDeviceType == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc primaryDeviceType failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->deviceName = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); + if (info->deviceName == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc deviceName failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->wfdDeviceInfo = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_WFD_DEVICE_INFO_LENGTH); + if (info->wfdDeviceInfo == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc wfdDeviceInfo failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->operSsid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); + if (info->operSsid == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc operSsid failed!"); + free(reply); + HdiP2pDeviceInfoFree(info, false); + return HDF_FAILURE; + } + info->srcAddressLen = ETH_ADDR_LEN + 1; + info->p2pDeviceAddressLen = ETH_ADDR_LEN + 1; + info->primaryDeviceTypeLen = WIFI_P2P_DEVICE_TYPE_LENGTH; + info->deviceNameLen = WIFI_P2P_DEVICE_NAME_LENGTH; + info->wfdDeviceInfoLen = WIFI_P2P_WFD_DEVICE_INFO_LENGTH; + info->operSsidLen = WIFI_P2P_DEVICE_NAME_LENGTH; + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(token, tmpBssid); + if (strcpy_s((char *)info->p2pDeviceAddress, ETH_ADDR_LEN + 1, (char *)tmpBssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + while (token != NULL) { + struct HdiWpaKeyValue retMsg = {{0}, {0}}; + GetStrKeyVal(token, "=", &retMsg); + if (strncmp(retMsg.key, "pri_dev_type", strlen("pri_dev_type")) == 0) { + if (strcpy_s((char *)info->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH + 1, retMsg.value) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else if (strncmp(retMsg.key, "device_name", strlen("device_name")) == 0) { + if (strcpy_s((char *)info->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } else if (strncmp(retMsg.key, "config_methods", strlen("config_methods")) == 0) { + info->configMethods = Hex2Dec(retMsg.value); + } else if (strncmp(retMsg.key, "dev_capab", strlen("dev_capab")) == 0) { + info->deviceCapabilities = Hex2Dec(retMsg.value); + } else if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) { + info->groupCapabilities = Hex2Dec(retMsg.value); + } else if (strncmp(retMsg.key, "oper_ssid", strlen("oper_ssid")) == 0) { + if (strcpy_s((char *)info->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } + token = strtok_r(NULL, "\n", &savedPtr); + } + pthread_mutex_unlock(GetInterfaceLock()); + free(reply); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char *ifName, + const char *bssid, int32_t *cap) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || bssid == NULL || cap == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + char *reply; + const int replySize = REPLY_SIZE; + char cmd[CMD_SIZE]; + + reply = (char *)malloc(replySize); + if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is NULL!", __func__); + return HDF_FAILURE; + } + + int32_t ret = 0; + (void)self; + + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + free(reply); + return HDF_FAILURE; + } + + if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("P2P_PEER command failed!"); + free(reply); + return HDF_FAILURE; + } + + if (strstr(reply, "\n") == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is error", __func__); + free(reply); + return HDF_FAILURE; + } + char *savedPtr = NULL; + char *token = strtok_r(reply, "\n", &savedPtr); + + while (token != NULL) { + struct HdiWpaKeyValue retMsg = {{0}, {0}}; + GetStrKeyVal(token, "=", &retMsg); + if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) { + *cap = Hex2Dec(retMsg.value); + } + token = strtok_r(NULL, "\n", &savedPtr); + } + pthread_mutex_unlock(GetInterfaceLock()); + free(reply); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifName, + struct HdiP2pNetworkList *infoList) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + if (ifName == NULL || infoList == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + char *reply; + const int replySize = REPLY_SIZE; + char cmd[CMD_SIZE]; + reply = (char *)malloc(replySize); + if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is NULL!", __func__); + return HDF_FAILURE; + } + + (void)self; + if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s LIST_NETWORKS", ifName) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("snprintf err"); + free(reply); + return HDF_FAILURE; + } + if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("LIST_NETWORKS command failed!"); + free(reply); + return HDF_FAILURE; + } + + char *token = strstr(reply, "\n"); + if (token == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s token is NULL!", __func__); + free(reply); + return HDF_FAILURE; + } + char *tmpPos = token + 1; + while ((tmpPos = strstr(tmpPos, "\n")) != NULL) { + infoList->infoNum += 1; + ++tmpPos; + } + if (infoList->infoNum <= 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s infoList->infoNum <= 0", __func__); + free(reply); + return HDF_FAILURE; + } + infoList->infos = (struct HdiP2pNetworkInfo *)OsalMemCalloc(sizeof(struct HdiP2pNetworkInfo) * infoList->infoNum); + if (infoList->infos == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("malloc infos failed!"); + free(reply); + return HDF_FAILURE; + } + infoList->infosLen = (uint32_t)infoList->infoNum; + char *tmpBuf = token + 1; + char *savedPtr = NULL; + token = strtok_r(tmpBuf, "\n", &savedPtr); + int index = 0; + while (token != NULL) { + if (index >= infoList->infoNum) { + break; + } + infoList->infos[index].ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_SSID_LENGTH); + if (infoList->infos[index].ssid == NULL) { + HDF_LOGE("malloc ssid failed!"); + HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); + break; + } + infoList->infos[index].ssidLen = WIFI_SSID_LENGTH; + infoList->infos[index].bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (infoList->infos[index].bssid == NULL) { + HDF_LOGE("malloc bssid failed!"); + HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); + break; + } + infoList->infos[index].bssidLen = ETH_ADDR_LEN + 1; + infoList->infos[index].flags = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_NETWORK_FLAGS_LENGTH); + if (infoList->infos[index].flags == NULL) { + HDF_LOGE("malloc flags failed!"); + HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); + break; + } + infoList->infos[index].flagsLen = WIFI_NETWORK_FLAGS_LENGTH; + GetHalNetworkInfos(token, &(infoList->infos[index])); + index++; + token = strtok_r(NULL, "\n", &savedPtr); + } + pthread_mutex_unlock(GetInterfaceLock()); + free(reply); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceP2pSaveConfig(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pMainIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdStoreConfig(pMainIfc); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDeliverP2pData(struct IWpaInterface *self, const char *ifName, + int32_t cmdType, int32_t dataType, const char *carryData) +{ + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + (void)self; + (void)ifName; + char cmd[CMD_SIZE] = {0}; + char buf[CMD_SIZE] = {0}; + + int32_t ret = 0; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, + "IFNAME=%s P2P_DELIVER_DATA cmdType=%d dataType=%d carryData=%s", ifName, cmdType, dataType, carryData); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); + return HDF_FAILURE; + } + if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s command failed!", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s success", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceVendorExtProcessCmd(struct IWpaInterface *self, const char *ifName, const char *cmd) +{ +#define NEW_CMD_MAX_LEN 400 + HDF_LOGI("Ready to enter hdi %{public}s", __func__); + int32_t ret = 0; + (void)self; + if (cmd == NULL || ifName == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + pthread_mutex_lock(GetInterfaceLock()); + char *reply; + const int replySize = REPLY_SIZE; + reply = (char *)malloc(replySize); + if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s reply is NULL!", __func__); + return HDF_FAILURE; + } + + char newCmd[NEW_CMD_MAX_LEN] = {0}; + if (snprintf_s(newCmd, sizeof(newCmd), sizeof(newCmd) - 1, "IFNAME=%s %s", ifName, cmd) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: snprintf_s is failed, error code: %{public}d", __func__, ret); + free(reply); + return HDF_FAILURE; + } + + if (WpaCliCmd(newCmd, reply, replySize) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s WpaCliCmd failed!", __func__); + free(reply); + return HDF_FAILURE; + } +<<<<<<< HEAD + + HDF_LOGI("%{public}s reply %{public}s !", __func__, reply); +======= + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s cmd %{public}s reply %{public}s !", __func__, newCmd, reply); +>>>>>>> da9bf65ec (TicketNo:DTS2024081411562) + ret = atoi(reply); + free(reply); + return ret; +} + +static int32_t WpaFillP2pDeviceFoundParam(struct P2pDeviceInfoParam *deviceInfoParam, + struct HdiP2pDeviceInfoParam *hdiP2pDeviceInfoParam) +{ + int32_t ret = 0; + if (deviceInfoParam == NULL || hdiP2pDeviceInfoParam == NULL) { + HDF_LOGE("%{public}s: deviceInfoParam or hdiP2pDeviceInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pDeviceInfoParam->configMethods = deviceInfoParam->configMethods; + hdiP2pDeviceInfoParam->deviceCapabilities = deviceInfoParam->deviceCapabilities; + hdiP2pDeviceInfoParam->groupCapabilities = deviceInfoParam->groupCapabilities; + hdiP2pDeviceInfoParam->wfdLength = deviceInfoParam->wfdLength; + + do { + if (FillData(&hdiP2pDeviceInfoParam->srcAddress, &hdiP2pDeviceInfoParam->srcAddressLen, + deviceInfoParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pDeviceInfoParam->p2pDeviceAddress, &hdiP2pDeviceInfoParam->p2pDeviceAddressLen, + deviceInfoParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pDeviceInfoParam->primaryDeviceType, &hdiP2pDeviceInfoParam->primaryDeviceTypeLen, + deviceInfoParam->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pDeviceInfoParam->deviceName, &hdiP2pDeviceInfoParam->deviceNameLen, + deviceInfoParam->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (deviceInfoParam->wfdLength != 0 && + FillData(&hdiP2pDeviceInfoParam->wfdDeviceInfo, &hdiP2pDeviceInfoParam->wfdDeviceInfoLen, + deviceInfoParam->wfdDeviceInfo, deviceInfoParam->wfdLength) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pDeviceInfoParam->operSsid, &hdiP2pDeviceInfoParam->operSsidLen, + deviceInfoParam->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill reason fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pDeviceInfoParam->srcAddress != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->srcAddress); + hdiP2pDeviceInfoParam->srcAddress = NULL; + } + if (hdiP2pDeviceInfoParam->p2pDeviceAddress != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->p2pDeviceAddress); + hdiP2pDeviceInfoParam->p2pDeviceAddress = NULL; + } + if (hdiP2pDeviceInfoParam->primaryDeviceType != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->primaryDeviceType); + hdiP2pDeviceInfoParam->primaryDeviceType = NULL; + } + if (hdiP2pDeviceInfoParam->deviceName != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->deviceName); + hdiP2pDeviceInfoParam->deviceName = NULL; + } + if (hdiP2pDeviceInfoParam->wfdDeviceInfo != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->wfdDeviceInfo); + hdiP2pDeviceInfoParam->wfdDeviceInfo = NULL; + } + if (hdiP2pDeviceInfoParam->operSsid != NULL) { + OsalMemFree(hdiP2pDeviceInfoParam->operSsid); + hdiP2pDeviceInfoParam->operSsid = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pDeviceLostParam(struct P2pDeviceLostParam *deviceLostParam, + struct HdiP2pDeviceLostParam *hdiP2pDeviceLostParam) +{ + int32_t ret = 0; + if (deviceLostParam == NULL || hdiP2pDeviceLostParam == NULL) { + HDF_LOGE("%{public}s: deviceLostParam or hdiP2pDeviceLostParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pDeviceLostParam->networkId = deviceLostParam->networkId; + + if (FillData(&hdiP2pDeviceLostParam->p2pDeviceAddress, &hdiP2pDeviceLostParam->p2pDeviceAddressLen, + deviceLostParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiP2pDeviceLostParam->p2pDeviceAddress != NULL) { + OsalMemFree(hdiP2pDeviceLostParam->p2pDeviceAddress); + hdiP2pDeviceLostParam->p2pDeviceAddress = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pGoNegotiationRequestParam(struct P2pGoNegotiationRequestParam *goNegotiationRequestParam, + struct HdiP2pGoNegotiationRequestParam *hdiP2pGoNegotiationRequestParam) +{ + int32_t ret = 0; + if (goNegotiationRequestParam == NULL || hdiP2pGoNegotiationRequestParam == NULL) { + HDF_LOGE("%{public}s: goNegotiationRequestParam or hdiP2pGoNegotiationRequestParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pGoNegotiationRequestParam->passwordId = goNegotiationRequestParam->passwordId; + + if (FillData(&hdiP2pGoNegotiationRequestParam->srcAddress, &hdiP2pGoNegotiationRequestParam->srcAddressLen, + goNegotiationRequestParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiP2pGoNegotiationRequestParam->srcAddress != NULL) { + OsalMemFree(hdiP2pGoNegotiationRequestParam->srcAddress); + hdiP2pGoNegotiationRequestParam->srcAddress = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pGoNegotiationCompletedParam(struct P2pGoNegotiationCompletedParam + *goNegotiationCompletedParam, struct HdiP2pGoNegotiationCompletedParam *hdiP2pGoNegotiationCompletedParam) +{ + int32_t ret = 0; + if (goNegotiationCompletedParam == NULL || hdiP2pGoNegotiationCompletedParam == NULL) { + HDF_LOGE("%{public}s: goNegotiationCompletedParam or hdiP2pGoNegotiationCompletedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pGoNegotiationCompletedParam->status = goNegotiationCompletedParam->status; + return ret; +} + +static int32_t WpaFillP2pInvitationReceivedParam(struct P2pInvitationReceivedParam *invitationReceivedParam, + struct HdiP2pInvitationReceivedParam *hdiP2pInvitationReceivedParam) +{ + int32_t ret = HDF_SUCCESS; + if (invitationReceivedParam == NULL || hdiP2pInvitationReceivedParam == NULL) { + HDF_LOGE("%{public}s: invitationReceivedParam or hdiP2pInvitationReceivedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pInvitationReceivedParam->type = invitationReceivedParam->type; + hdiP2pInvitationReceivedParam->persistentNetworkId = invitationReceivedParam->persistentNetworkId; + hdiP2pInvitationReceivedParam->operatingFrequency = invitationReceivedParam->operatingFrequency; + + do { + if (FillData(&hdiP2pInvitationReceivedParam->srcAddress, &hdiP2pInvitationReceivedParam->srcAddressLen, + invitationReceivedParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pInvitationReceivedParam->goDeviceAddress, + &hdiP2pInvitationReceivedParam->goDeviceAddressLen, + invitationReceivedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pInvitationReceivedParam->bssid, &hdiP2pInvitationReceivedParam->bssidLen, + invitationReceivedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pInvitationReceivedParam->srcAddress != NULL) { + OsalMemFree(hdiP2pInvitationReceivedParam->srcAddress); + hdiP2pInvitationReceivedParam->srcAddress = NULL; + } + if (hdiP2pInvitationReceivedParam->goDeviceAddress != NULL) { + OsalMemFree(hdiP2pInvitationReceivedParam->goDeviceAddress); + hdiP2pInvitationReceivedParam->goDeviceAddress = NULL; + } + if (hdiP2pInvitationReceivedParam->bssid != NULL) { + OsalMemFree(hdiP2pInvitationReceivedParam->bssid); + hdiP2pInvitationReceivedParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pInvitationResultParam(struct P2pInvitationResultParam *invitationResultParam, + struct HdiP2pInvitationResultParam *hdiP2pInvitationResultParam) +{ + int32_t ret = HDF_SUCCESS; + if (invitationResultParam == NULL || hdiP2pInvitationResultParam == NULL) { + HDF_LOGE("%{public}s: invitationResultParam or hdiP2pInvitationResultParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pInvitationResultParam->status = invitationResultParam->status; + + if (FillData(&hdiP2pInvitationResultParam->bssid, &hdiP2pInvitationResultParam->bssidLen, + invitationResultParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiP2pInvitationResultParam->bssid != NULL) { + OsalMemFree(hdiP2pInvitationResultParam->bssid); + hdiP2pInvitationResultParam->bssid = NULL; + } + } + return ret; +} + +static int32_t FillHdiP2pGroupInfoStartedParam(struct P2pGroupStartedParam *groupStartedParam, + struct HdiP2pGroupInfoStartedParam *hdiP2pGroupStartedParam) +{ + int32_t ret = HDF_SUCCESS; + if (groupStartedParam == NULL || hdiP2pGroupStartedParam == NULL) { + HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupStartedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + if (FillData(&hdiP2pGroupStartedParam->groupIfName, &hdiP2pGroupStartedParam->groupIfNameLen, + groupStartedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill groupIfName fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pGroupStartedParam->ssid, &hdiP2pGroupStartedParam->ssidLen, + groupStartedParam->ssid, WIFI_SSID_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pGroupStartedParam->psk, &hdiP2pGroupStartedParam->pskLen, + groupStartedParam->psk, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill psk fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pGroupStartedParam->passphrase, &hdiP2pGroupStartedParam->passphraseLen, + groupStartedParam->passphrase, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill passphrase fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pGroupStartedParam->goDeviceAddress, &hdiP2pGroupStartedParam->goDeviceAddressLen, + groupStartedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill goDeviceAddress fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiP2pGroupStartedParam->goRandomDeviceAddress, + &hdiP2pGroupStartedParam->goRandomDeviceAddressLen, + groupStartedParam->goRandomDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill goRandomDeviceAddress fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + return ret; +} + +static int32_t WpaFillP2pGroupInfoStartedParam(struct P2pGroupStartedParam *groupStartedParam, + struct HdiP2pGroupInfoStartedParam *hdiP2pGroupStartedParam) +{ + int32_t ret = HDF_SUCCESS; + if (groupStartedParam == NULL || hdiP2pGroupStartedParam == NULL) { + HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupStartedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pGroupStartedParam->isGo = groupStartedParam->isGo; + hdiP2pGroupStartedParam->isPersistent = groupStartedParam->isPersistent; + hdiP2pGroupStartedParam->frequency = groupStartedParam->frequency; + ret = FillHdiP2pGroupInfoStartedParam(groupStartedParam, hdiP2pGroupStartedParam); + if (ret != HDF_SUCCESS) { + if (hdiP2pGroupStartedParam->groupIfName != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->groupIfName); + hdiP2pGroupStartedParam->groupIfName = NULL; + } + if (hdiP2pGroupStartedParam->ssid != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->ssid); + hdiP2pGroupStartedParam->ssid = NULL; + } + if (hdiP2pGroupStartedParam->psk != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->psk); + hdiP2pGroupStartedParam->psk = NULL; + } + if (hdiP2pGroupStartedParam->passphrase != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->passphrase); + hdiP2pGroupStartedParam->passphrase = NULL; + } + if (hdiP2pGroupStartedParam->goDeviceAddress != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->goDeviceAddress); + hdiP2pGroupStartedParam->goDeviceAddress = NULL; + } + if (hdiP2pGroupStartedParam->goRandomDeviceAddress != NULL) { + OsalMemFree(hdiP2pGroupStartedParam->goRandomDeviceAddress); + hdiP2pGroupStartedParam->goRandomDeviceAddress = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pGroupRemovedParam(struct P2pGroupRemovedParam *groupRemovedParam, + struct HdiP2pGroupRemovedParam *hdiP2pGroupRemovedParam) +{ + int32_t ret = HDF_SUCCESS; + if (groupRemovedParam == NULL || hdiP2pGroupRemovedParam == NULL) { + HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupRemovedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pGroupRemovedParam->isGo = groupRemovedParam->isGo; + + if (FillData(&hdiP2pGroupRemovedParam->groupIfName, &hdiP2pGroupRemovedParam->groupIfNameLen, + groupRemovedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiP2pGroupRemovedParam->groupIfName != NULL) { + OsalMemFree(hdiP2pGroupRemovedParam->groupIfName); + hdiP2pGroupRemovedParam->groupIfName = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pProvisionDiscoveryCompletedParam(struct P2pProvisionDiscoveryCompletedParam + *provisionDiscoveryCompletedParam, + struct HdiP2pProvisionDiscoveryCompletedParam *hdiP2pProvisionDiscoveryCompletedParam) +{ + int32_t ret = HDF_SUCCESS; + if (provisionDiscoveryCompletedParam == NULL || hdiP2pProvisionDiscoveryCompletedParam == NULL) { + HDF_LOGE("%{public}s: provisionDiscoveryCompletedParam or hdiP2pProvisionDiscoveryCompletedParam is NULL!", + __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pProvisionDiscoveryCompletedParam->isRequest = provisionDiscoveryCompletedParam->isRequest; + hdiP2pProvisionDiscoveryCompletedParam->provDiscStatusCode = provisionDiscoveryCompletedParam->provDiscStatusCode; + hdiP2pProvisionDiscoveryCompletedParam->configMethods = provisionDiscoveryCompletedParam->configMethods; + + do { + if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress, + &hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddressLen, + provisionDiscoveryCompletedParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->generatedPin, + &hdiP2pProvisionDiscoveryCompletedParam->generatedPinLen, + provisionDiscoveryCompletedParam->generatedPin, WIFI_PIN_CODE_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress != NULL) { + OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress); + hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress = NULL; + } + if (hdiP2pProvisionDiscoveryCompletedParam->generatedPin != NULL) { + OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->generatedPin); + hdiP2pProvisionDiscoveryCompletedParam->generatedPin = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pServDiscReqParam(struct P2pServDiscReqInfoParam *servDiscReqInfo, + struct HdiP2pServDiscReqInfoParam *hdiP2pServDiscReqInfo) +{ + int32_t ret = HDF_SUCCESS; + if (servDiscReqInfo == NULL || hdiP2pServDiscReqInfo == NULL) { + HDF_LOGE("%{public}s: servDiscReqInfo or hdiP2pServDiscReqInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pServDiscReqInfo->freq = servDiscReqInfo->freq; + hdiP2pServDiscReqInfo->dialogToken = servDiscReqInfo->dialogToken; + hdiP2pServDiscReqInfo->updateIndic = servDiscReqInfo->updateIndic; + + do { + if (FillData(&hdiP2pServDiscReqInfo->mac, &hdiP2pServDiscReqInfo->macLen, + servDiscReqInfo->mac, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pServDiscReqInfo->tlvs, &hdiP2pServDiscReqInfo->tlvsLen, + servDiscReqInfo->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pServDiscReqInfo->mac != NULL) { + OsalMemFree(hdiP2pServDiscReqInfo->mac); + hdiP2pServDiscReqInfo->mac = NULL; + } + if (hdiP2pServDiscReqInfo->tlvs != NULL) { + OsalMemFree(hdiP2pServDiscReqInfo->tlvs); + hdiP2pServDiscReqInfo->tlvs = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pServDiscRespParam(struct P2pServDiscRespParam *servDiscRespParam, + struct HdiP2pServDiscRespParam *hdiP2pServDiscRespParam) +{ + int32_t ret = HDF_SUCCESS; + if (servDiscRespParam == NULL || hdiP2pServDiscRespParam == NULL) { + HDF_LOGE("%{public}s: servDiscRespParam or hdiP2pServDiscRespParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pServDiscRespParam->updateIndicator = servDiscRespParam->updateIndicator; + + do { + if (FillData(&hdiP2pServDiscRespParam->srcAddress, &hdiP2pServDiscRespParam->srcAddressLen, + servDiscRespParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pServDiscRespParam->tlvs, &hdiP2pServDiscRespParam->tlvsLen, + servDiscRespParam->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pServDiscRespParam->srcAddress != NULL) { + OsalMemFree(hdiP2pServDiscRespParam->srcAddress); + hdiP2pServDiscRespParam->srcAddress = NULL; + } + if (hdiP2pServDiscRespParam->tlvs != NULL) { + OsalMemFree(hdiP2pServDiscRespParam->tlvs); + hdiP2pServDiscRespParam->tlvs = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pStaConnectStateParam(struct P2pStaConnectStateParam *staConnectStateParam, + struct HdiP2pStaConnectStateParam *hdiP2pStaConnectStateParam) +{ + int32_t ret = HDF_SUCCESS; + if (staConnectStateParam == NULL || hdiP2pStaConnectStateParam == NULL) { + HDF_LOGE("%{public}s: staConnectStateParam or hdiP2pStaConnectStateParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pStaConnectStateParam->state = staConnectStateParam->state; + do { + if (FillData(&hdiP2pStaConnectStateParam->srcAddress, &hdiP2pStaConnectStateParam->srcAddressLen, + staConnectStateParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiP2pStaConnectStateParam->p2pDeviceAddress, &hdiP2pStaConnectStateParam->p2pDeviceAddressLen, + staConnectStateParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + + if (ret != HDF_SUCCESS) { + if (hdiP2pStaConnectStateParam->srcAddress != NULL) { + OsalMemFree(hdiP2pStaConnectStateParam->srcAddress); + hdiP2pStaConnectStateParam->srcAddress = NULL; + } + if (hdiP2pStaConnectStateParam->p2pDeviceAddress != NULL) { + OsalMemFree(hdiP2pStaConnectStateParam->p2pDeviceAddress); + hdiP2pStaConnectStateParam->p2pDeviceAddress = NULL; + } + } + return ret; +} + +static int32_t WpaFillP2pIfaceCreatedParam(struct P2pIfaceCreatedParam *ifaceCreatedParam, + struct HdiP2pIfaceCreatedParam *hdiP2pIfaceCreatedParam) +{ + int32_t ret = HDF_SUCCESS; + if (ifaceCreatedParam == NULL || hdiP2pIfaceCreatedParam == NULL) { + HDF_LOGE("%{public}s: ifaceCreatedParam or hdiP2pIfaceCreatedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiP2pIfaceCreatedParam->isGo = ifaceCreatedParam->isGo; + return ret; +} + +int32_t ProcessEventP2pDeviceFound(struct HdfWpaRemoteNode *node, + struct P2pDeviceInfoParam *deviceInfoParam, const char *ifName) +{ + struct HdiP2pDeviceInfoParam hdiP2pDeviceInfo = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceFound == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pDeviceFoundParam(deviceInfoParam, &hdiP2pDeviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pDeviceInfo is NULL or deviceInfoParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventDeviceFound(node->callbackObj, &hdiP2pDeviceInfo, ifName); + } + HdiP2pDeviceInfoParamFree(&hdiP2pDeviceInfo, false); + return ret; +} + +int32_t ProcessEventP2pDeviceLost(struct HdfWpaRemoteNode *node, + struct P2pDeviceLostParam *deviceLostParam, const char *ifName) +{ + struct HdiP2pDeviceLostParam hdiP2pDeviceLostParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceLost == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pDeviceLostParam(deviceLostParam, &hdiP2pDeviceLostParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pDeviceLostParam is NULL or deviceLostParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventDeviceLost(node->callbackObj, &hdiP2pDeviceLostParam, ifName); + } + HdiP2pDeviceLostParamFree(&hdiP2pDeviceLostParam, false); + return ret; +} + +int32_t ProcessEventP2pGoNegotiationRequest(struct HdfWpaRemoteNode *node, + struct P2pGoNegotiationRequestParam *goNegotiationRequestParam, const char *ifName) +{ + struct HdiP2pGoNegotiationRequestParam hdiP2pGoNegotiationRequestParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationRequest == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pGoNegotiationRequestParam(goNegotiationRequestParam, + &hdiP2pGoNegotiationRequestParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pGoNegotiationRequestParam is NULL or goNegotiationRequestParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventGoNegotiationRequest(node->callbackObj, + &hdiP2pGoNegotiationRequestParam, ifName); + } + HdiP2pGoNegotiationRequestParamFree(&hdiP2pGoNegotiationRequestParam, false); + return ret; +} + +int32_t ProcessEventP2pGoNegotiationCompleted(struct HdfWpaRemoteNode *node, struct P2pGoNegotiationCompletedParam + *goNegotiationCompletedParam, const char *ifName) +{ + struct HdiP2pGoNegotiationCompletedParam hdiP2pGoNegotiationCompletedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationCompleted == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pGoNegotiationCompletedParam(goNegotiationCompletedParam, + &hdiP2pGoNegotiationCompletedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pGoNegotiationCompletedParam is NULL or goNegotiationCompletedParam fialed!", + __func__); + } else { + ret = node->callbackObj->OnEventGoNegotiationCompleted(node->callbackObj, + &hdiP2pGoNegotiationCompletedParam, ifName); + } + HdiP2pGoNegotiationCompletedParamFree(&hdiP2pGoNegotiationCompletedParam, false); + return ret; +} + +int32_t ProcessEventP2pInvitationReceived(struct HdfWpaRemoteNode *node, + struct P2pInvitationReceivedParam *invitationReceivedParam, const char *ifName) +{ + struct HdiP2pInvitationReceivedParam hdiP2pInvitationReceivedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationReceived == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pInvitationReceivedParam(invitationReceivedParam, &hdiP2pInvitationReceivedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pInvitationReceivedParam is NULL or invitationReceivedParam fialed!", __func__); + return ret; + } else { + ret = node->callbackObj->OnEventInvitationReceived(node->callbackObj, &hdiP2pInvitationReceivedParam, ifName); + } + HdiP2pInvitationReceivedParamFree(&hdiP2pInvitationReceivedParam, false); + return ret; +} + +int32_t ProcessEventP2pInvitationResult(struct HdfWpaRemoteNode *node, + struct P2pInvitationResultParam *invitationResultParam, const char *ifName) +{ + struct HdiP2pInvitationResultParam hdiP2pInvitationResultParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationResult == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pInvitationResultParam(invitationResultParam, &hdiP2pInvitationResultParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pInvitationResultParam is NULL or invitationResultParam fialed!", __func__); + return ret; + } else { + ret = node->callbackObj->OnEventInvitationResult(node->callbackObj, &hdiP2pInvitationResultParam, ifName); + } + HdiP2pInvitationResultParamFree(&hdiP2pInvitationResultParam, false); + return ret; +} + +int32_t ProcessEventP2pGroupFormationSuccess(struct HdfWpaRemoteNode *node, + const char *ifName) +{ + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = node->callbackObj->OnEventGroupFormationSuccess(node->callbackObj, ifName); + return ret; +} + +int32_t ProcessEventP2pGroupFormationFailure(struct HdfWpaRemoteNode *node, char *reason, + const char *ifName) +{ + char *hdiReason = NULL; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupFormationFailure == NULL || + reason == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiReason = (char *)OsalMemCalloc(WIFI_REASON_LENGTH); + if ((hdiReason == NULL) || (strncpy_s(hdiReason, WIFI_REASON_LENGTH, reason, strlen(reason)) != HDF_SUCCESS)) { + HDF_LOGE("%{public}s: hdiReason is NULL or reason fialed!", __func__); + } else { + ret = node->callbackObj->OnEventGroupFormationFailure(node->callbackObj, hdiReason, ifName); + } + OsalMemFree(hdiReason); + hdiReason = NULL; + return ret; +} + +int32_t ProcessEventP2pGroupStarted(struct HdfWpaRemoteNode *node, + struct P2pGroupStartedParam *groupStartedParam, const char *ifName) +{ + struct HdiP2pGroupInfoStartedParam hdiP2pGroupInfoStartedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupInfoStarted == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pGroupInfoStartedParam(groupStartedParam, &hdiP2pGroupInfoStartedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pGroupStartedParam is NULL or groupStartedParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventGroupInfoStarted(node->callbackObj, &hdiP2pGroupInfoStartedParam, ifName); + } + HdiP2pGroupInfoStartedParamFree(&hdiP2pGroupInfoStartedParam, false); + return ret; +} + +int32_t ProcessEventP2pGroupRemoved(struct HdfWpaRemoteNode *node, + struct P2pGroupRemovedParam *groupRemovedParam, const char *ifName) +{ + struct HdiP2pGroupRemovedParam hdiP2pGroupRemovedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupRemoved == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pGroupRemovedParam(groupRemovedParam, &hdiP2pGroupRemovedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pGroupRemovedParam is NULL or groupRemovedParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventGroupRemoved(node->callbackObj, &hdiP2pGroupRemovedParam, ifName); + } + HdiP2pGroupRemovedParamFree(&hdiP2pGroupRemovedParam, false); + return ret; +} + +int32_t ProcessEventP2pProvisionDiscoveryCompleted(struct HdfWpaRemoteNode *node, + struct P2pProvisionDiscoveryCompletedParam *provisionDiscoveryCompletedParam, const char *ifName) +{ + struct HdiP2pProvisionDiscoveryCompletedParam hdiP2pProvisionDiscoveryCompletedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventProvisionDiscoveryCompleted == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pProvisionDiscoveryCompletedParam(provisionDiscoveryCompletedParam, + &hdiP2pProvisionDiscoveryCompletedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Param is NULL or provisionDiscoveryCompletedParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventProvisionDiscoveryCompleted(node->callbackObj, + &hdiP2pProvisionDiscoveryCompletedParam, ifName); + } + HdiP2pProvisionDiscoveryCompletedParamFree(&hdiP2pProvisionDiscoveryCompletedParam, false); + return ret; +} + +int32_t ProcessEventP2pFindStopped(struct HdfWpaRemoteNode *node, + const char *ifName) +{ + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = node->callbackObj->OnEventFindStopped(node->callbackObj, ifName); + return ret; +} + +int32_t ProcessEventP2pServDiscReq(struct HdfWpaRemoteNode *node, + struct P2pServDiscReqInfoParam *servDiscReqInfo, const char *ifName) +{ + struct HdiP2pServDiscReqInfoParam hdiP2pServDiscReqInfo = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscReq == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pServDiscReqParam(servDiscReqInfo, &hdiP2pServDiscReqInfo) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pServDiscReqInfo is NULL or servDiscReqInfo fialed!", __func__); + } else { + ret = node->callbackObj->OnEventServDiscReq(node->callbackObj, &hdiP2pServDiscReqInfo, ifName); + } + HdiP2pServDiscReqInfoParamFree(&hdiP2pServDiscReqInfo, false); + return ret; +} + +int32_t ProcessEventP2pServDiscResp(struct HdfWpaRemoteNode *node, + struct P2pServDiscRespParam *servDiscRespParam, const char *ifName) +{ + struct HdiP2pServDiscRespParam hdiP2pServDiscRespParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscResp == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pServDiscRespParam(servDiscRespParam, &hdiP2pServDiscRespParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pServDiscRespParam is NULL or servDiscRespParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventServDiscResp(node->callbackObj, &hdiP2pServDiscRespParam, ifName); + } + HdiP2pServDiscRespParamFree(&hdiP2pServDiscRespParam, false); + return ret; +} + +int32_t ProcessEventP2pStaConnectState(struct HdfWpaRemoteNode *node, + struct P2pStaConnectStateParam *staConnectStateParam, const char *ifName) +{ + struct HdiP2pStaConnectStateParam hdiP2pStaConnectStateParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaConnectState == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pStaConnectStateParam(staConnectStateParam, &hdiP2pStaConnectStateParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pStaConnectStateParam is NULL or staConnectStateParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventStaConnectState(node->callbackObj, &hdiP2pStaConnectStateParam, ifName); + } + HdiP2pStaConnectStateParamFree(&hdiP2pStaConnectStateParam, false); + return ret; +} + +int32_t ProcessEventP2pIfaceCreated(struct HdfWpaRemoteNode *node, struct P2pIfaceCreatedParam *ifaceCreatedParam, + const char *ifName) +{ + struct HdiP2pIfaceCreatedParam hdiP2pIfaceCreatedParam = {0}; + int32_t ret = HDF_FAILURE; + if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventIfaceCreated == NULL) { + HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (WpaFillP2pIfaceCreatedParam(ifaceCreatedParam, &hdiP2pIfaceCreatedParam) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: hdiP2pIfaceCreatedParam is NULL or ifaceCreatedParam fialed!", __func__); + } else { + ret = node->callbackObj->OnEventIfaceCreated(node->callbackObj, &hdiP2pIfaceCreatedParam, ifName); + } + HdiP2pIfaceCreatedParamFree(&hdiP2pIfaceCreatedParam, false); + return ret; +} -- Gitee From e6cfbaaa57ddead95581b69537beca9fdd8a21c4 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:37:14 +0000 Subject: [PATCH 0284/1485] update wlan/wpa/client/src/wpa_client.c. Signed-off-by: xionglei --- wlan/wpa/client/src/wpa_client.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/wlan/wpa/client/src/wpa_client.c b/wlan/wpa/client/src/wpa_client.c index f9722c4afd..c0da230c6c 100644 --- a/wlan/wpa/client/src/wpa_client.c +++ b/wlan/wpa/client/src/wpa_client.c @@ -31,7 +31,6 @@ extern "C" { #define EOK 0 #endif - #define MAX_CALL_BACK_COUNT 10 static struct WpaCallbackEvent *g_wpaCallbackEventMap[MAX_CALL_BACK_COUNT] = {NULL}; static pthread_mutex_t g_wpaCallbackMutex = PTHREAD_MUTEX_INITIALIZER; @@ -112,8 +111,7 @@ void ReleaseEventCallback(void) { pthread_mutex_lock(&g_wpaCallbackMutex); for (uint32_t i = 0; i < MAX_CALL_BACK_COUNT; i++) { - if (g_wpaCallbackEventMap[i] != NULL && - (strncmp(g_wpaCallbackEventMap[i]->ifName, "chba", strlen("chba")) == 0)) { + if (g_wpaCallbackEventMap[i] != NULL) { g_wpaCallbackEventMap[i]->onRecFunc = NULL; free(g_wpaCallbackEventMap[i]); g_wpaCallbackEventMap[i] = NULL; -- Gitee From 8871ff237e2a1b6da380dede7b585a1ffa3bc837 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:43:26 +0000 Subject: [PATCH 0285/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c. Signed-off-by: xionglei --- .../service_common/hdi_wpa_common.c | 39 ------------------- 1 file changed, 39 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c index 8c6e98d09f..4d41802088 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.c @@ -27,13 +27,6 @@ #define DEC_MAX_SCOPE 10 #define WPA_CMD_RETURN_TIMEOUT (-2) -static pthread_mutex_t g_mutexSta = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t g_mutexP2p = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t g_mutexChba = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t g_mutexCommon = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t g_mutexWpa = PTHREAD_MUTEX_INITIALIZER; - - int Hex2Dec(const char *str) { if (str == NULL || strncasecmp(str, "0x", strlen("0x")) != 0) { @@ -119,12 +112,9 @@ int InitWpaCtrl(WpaCtrl *pCtrl, const char *ifname) static int StaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) { - pthread_mutex_lock(&g_mutexSta); - HDF_LOGI("enter StaCliCmd"); if (ctrl == NULL || ctrl->pSend == NULL || cmd == NULL || buf == NULL || bufLen == 0) { HDF_LOGE("StaCliCmd, invalid parameters!"); - pthread_mutex_unlock(&g_mutexSta); return -1; } size_t len = bufLen - 1; @@ -132,11 +122,9 @@ static int StaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) int ret = wpa_ctrl_request(ctrl->pSend, cmd, strlen(cmd), buf, &len, NULL); if (ret == WPA_CMD_RETURN_TIMEOUT) { HDF_LOGE("[%{private}s] command timed out.", cmd); - pthread_mutex_unlock(&g_mutexSta); return WPA_CMD_RETURN_TIMEOUT; } else if (ret < 0) { HDF_LOGE("[%{private}s] command failed.", cmd); - pthread_mutex_unlock(&g_mutexSta); return -1; } buf[len] = '\0'; @@ -144,21 +132,16 @@ static int StaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) if (strncmp(buf, "FAIL\n", strlen("FAIL\n")) == 0 || strncmp(buf, "UNKNOWN COMMAND\n", strlen("UNKNOWN COMMAND\n")) == 0) { HDF_LOGE("%{private}s request success, but response %{public}s", cmd, buf); - pthread_mutex_unlock(&g_mutexSta); return -1; } - pthread_mutex_unlock(&g_mutexSta); return 0; } static int P2pCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) { - pthread_mutex_lock(&g_mutexP2p); - HDF_LOGI("enter P2pCliCmd"); if (ctrl == NULL || ctrl->pSend == NULL || cmd == NULL || buf == NULL || bufLen == 0) { HDF_LOGE("P2pCliCmd, invalid parameters!"); - pthread_mutex_unlock(&g_mutexP2p); return -1; } size_t len = bufLen - 1; @@ -166,11 +149,9 @@ static int P2pCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) int ret = wpa_ctrl_request(ctrl->pSend, cmd, strlen(cmd), buf, &len, NULL); if (ret == WPA_CMD_RETURN_TIMEOUT) { HDF_LOGE("[%{private}s] command timed out.", cmd); - pthread_mutex_unlock(&g_mutexP2p); return WPA_CMD_RETURN_TIMEOUT; } else if (ret < 0) { HDF_LOGE("[%{private}s] command failed.", cmd); - pthread_mutex_unlock(&g_mutexP2p); return -1; } buf[len] = '\0'; @@ -178,21 +159,16 @@ static int P2pCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) if (strncmp(buf, "FAIL\n", strlen("FAIL\n")) == 0 || strncmp(buf, "UNKNOWN COMMAND\n", strlen("UNKNOWN COMMAND\n")) == 0) { HDF_LOGE("%{private}s request success, but response %{public}s", cmd, buf); - pthread_mutex_unlock(&g_mutexP2p); return -1; } - pthread_mutex_unlock(&g_mutexP2p); return 0; } static int ChbaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) { - pthread_mutex_lock(&g_mutexChba); - HDF_LOGI("enter ChbaCliCmd"); if (ctrl == NULL || ctrl->pSend == NULL || cmd == NULL || buf == NULL || bufLen == 0) { HDF_LOGE("ChbaCliCmd, invalid parameters!"); - pthread_mutex_unlock(&g_mutexChba); return -1; } size_t len = bufLen - 1; @@ -200,11 +176,9 @@ static int ChbaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) int ret = wpa_ctrl_request(ctrl->pSend, cmd, strlen(cmd), buf, &len, NULL); if (ret == WPA_CMD_RETURN_TIMEOUT) { HDF_LOGE("[%{private}s] command timed out.", cmd); - pthread_mutex_unlock(&g_mutexChba); return WPA_CMD_RETURN_TIMEOUT; } else if (ret < 0) { HDF_LOGE("[%{private}s] command failed.", cmd); - pthread_mutex_unlock(&g_mutexChba); return -1; } buf[len] = '\0'; @@ -212,21 +186,16 @@ static int ChbaCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) if (strncmp(buf, "FAIL\n", strlen("FAIL\n")) == 0 || strncmp(buf, "UNKNOWN COMMAND\n", strlen("UNKNOWN COMMAND\n")) == 0) { HDF_LOGE("%{private}s request success, but response %{public}s", cmd, buf); - pthread_mutex_unlock(&g_mutexChba); return -1; } - pthread_mutex_unlock(&g_mutexChba); return 0; } static int CommonCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen) { - pthread_mutex_lock(&g_mutexCommon); - HDF_LOGI("enter CommonCliCmd"); if (ctrl == NULL || ctrl->pSend == NULL || cmd == NULL || buf == NULL || bufLen == 0) { HDF_LOGE("CommonCliCmd, invalid parameters!"); - pthread_mutex_unlock(&g_mutexCommon); return -1; } size_t len = bufLen - 1; @@ -234,11 +203,9 @@ static int CommonCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen int ret = wpa_ctrl_request(ctrl->pSend, cmd, strlen(cmd), buf, &len, NULL); if (ret == WPA_CMD_RETURN_TIMEOUT) { HDF_LOGE("[%{private}s] command timed out.", cmd); - pthread_mutex_unlock(&g_mutexCommon); return WPA_CMD_RETURN_TIMEOUT; } else if (ret < 0) { HDF_LOGE("[%{private}s] command failed.", cmd); - pthread_mutex_unlock(&g_mutexCommon); return -1; } buf[len] = '\0'; @@ -246,10 +213,8 @@ static int CommonCliCmd(WpaCtrl *ctrl, const char *cmd, char *buf, size_t bufLen if (strncmp(buf, "FAIL\n", strlen("FAIL\n")) == 0 || strncmp(buf, "UNKNOWN COMMAND\n", strlen("UNKNOWN COMMAND\n")) == 0) { HDF_LOGE("%{private}s request success, but response %{public}s", cmd, buf); - pthread_mutex_unlock(&g_mutexCommon); return -1; } - pthread_mutex_unlock(&g_mutexCommon); return 0; } @@ -263,7 +228,6 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) return ret; } char *ifName = NULL; - pthread_mutex_lock(&g_mutexWpa); if (strncmp(cmd, "IFNAME=", strlen("IFNAME=")) == 0) { ifName = (char *)cmd + strlen("IFNAME="); } else if (strncmp(cmd, "INTERFACE_ADD ", strlen("INTERFACE_ADD ")) == 0) { @@ -294,7 +258,6 @@ int WpaCliCmd(const char *cmd, char *buf, size_t bufLen) ReleaseWpaGlobalInterface(); HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); } - pthread_mutex_unlock(&g_mutexWpa); return ret; } @@ -305,7 +268,6 @@ int IsSockRemoved(const char *ifName, int len) HDF_LOGE("ifname is invalid"); return ret; } - pthread_mutex_lock(&g_mutexWpa); if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { if (GetStaCtrl() == NULL) { ret = 0; @@ -319,6 +281,5 @@ int IsSockRemoved(const char *ifName, int len) ret = 0; } } - pthread_mutex_unlock(&g_mutexWpa); return ret; } -- Gitee From 864930ce282f40ffb50da6e825eeca2018a7ac1a Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:44:43 +0000 Subject: [PATCH 0286/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h | 1 - 1 file changed, 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h index d2c6e6c455..9586527bd8 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_common.h @@ -33,7 +33,6 @@ typedef struct StWpaCtrl { struct wpa_ctrl *pRecv; } WpaCtrl; - typedef struct StWpaKeyValue { char key[WPA_MESSAGE_KEY_LENGTH]; char value[WPA_MESSAGE_VALUE_LENGTH]; -- Gitee From de4bd7ad6e9b4286902073293467c34789c0421c Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:53:31 +0000 Subject: [PATCH 0287/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c. Signed-off-by: xionglei --- .../hdi_service/service_common/hdi_wpa_hal.c | 41 +++++-------------- 1 file changed, 10 insertions(+), 31 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index d73dfc723f..1e5aedf9cf 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -28,7 +28,6 @@ #undef LOG_TAG #define LOG_TAG "HdiWpaHal" - #define WPA_TRY_CONNECT_TIMES 20 #define WPA_TRY_CONNECT_SLEEP_TIME (100 * 1000) /* 100ms */ #define WPA_CMD_BUF_LEN 256 @@ -63,7 +62,6 @@ static const int MAX_IFACE_LEN = 6; #define WPA_CTRL_OPEN_IFNAME "@abstract:"CONFIG_ROOR_DIR"/sockets/wpa/wlan0" static WifiWpaInterface *g_wpaInterface = NULL; -static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; static int WpaCliConnect(WifiWpaInterface *p) { @@ -113,31 +111,25 @@ static void WpaCliClose(WifiWpaInterface *p) static int WpaCliAddIface(WifiWpaInterface *p, const AddInterfaceArgv *argv, bool isWpaAdd) { - pthread_mutex_lock(&g_mutex); - HDF_LOGI("enter WpaCliAddIface"); if (p == NULL || argv == NULL) { - pthread_mutex_unlock(&g_mutex); return -1; } WpaIfaceInfo *info = p->ifaces; while (info != NULL) { if (strncmp(info->name, argv->name, MAX_IFACE_LEN) == 0) { - pthread_mutex_unlock(&g_mutex); return 0; } info = info->next; } info = (WpaIfaceInfo *)calloc(1, sizeof(WpaIfaceInfo)); if (info == NULL) { - pthread_mutex_unlock(&g_mutex); return -1; } if (strcpy_s(info->name, sizeof(info->name), argv->name) != 0) { HDF_LOGI("WpaCliAddIface strcpy_s fail"); free(info); info = NULL; - pthread_mutex_unlock(&g_mutex); return -1; } char cmd[WPA_CMD_BUF_LEN] = {0}; @@ -148,23 +140,18 @@ static int WpaCliAddIface(WifiWpaInterface *p, const AddInterfaceArgv *argv, boo free(info); info = NULL; HDF_LOGI("WpaCliAddIface failed, cmd: %{public}s, buf: %{public}s", cmd, buf); - pthread_mutex_unlock(&g_mutex); return -1; } HDF_LOGI("Add interface finish, cmd: %{public}s, buf: %{public}s", cmd, buf); info->next = p->ifaces; p->ifaces = info; - pthread_mutex_unlock(&g_mutex); return 0; } static int WpaCliRemoveIface(WifiWpaInterface *p, const char *name) { - pthread_mutex_lock(&g_mutex); - HDF_LOGI("enter WpaCliRemoveIface."); if (p == NULL || name == NULL) { - pthread_mutex_unlock(&g_mutex); return -1; } WpaIfaceInfo *prev = NULL; @@ -178,14 +165,12 @@ static int WpaCliRemoveIface(WifiWpaInterface *p, const char *name) } if (info == NULL) { HDF_LOGI("the WpaInterface info is null"); - pthread_mutex_unlock(&g_mutex); return 0; } char cmd[WPA_CMD_BUF_LEN] = {0}; char buf[WPA_CMD_REPLY_BUF_SMALL_LEN] = {0}; if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "INTERFACE_REMOVE %s", name) < 0 || WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { - pthread_mutex_unlock(&g_mutex); return -1; } if (prev == NULL) { @@ -196,48 +181,42 @@ static int WpaCliRemoveIface(WifiWpaInterface *p, const char *name) HDF_LOGI("Remove interface finish, cmd: %{public}s, buf: %{public}s", cmd, buf); free(info); info = NULL; - pthread_mutex_unlock(&g_mutex); return 0; } static int WpaCliWpaTerminate(void) { - pthread_mutex_lock(&g_mutex); HDF_LOGI("enter WpaCliWpaTerminate."); char cmd[WPA_CMD_BUF_LEN] = {0}; char buf[WPA_CMD_REPLY_BUF_SMALL_LEN] = {0}; if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "TERMINATE") < 0) { HDF_LOGE("WpaCliWpaTerminate, snprintf err"); - pthread_mutex_unlock(&g_mutex); return -1; } - int ret = WpaCliCmd(cmd, buf, sizeof(buf)); - pthread_mutex_unlock(&g_mutex); - return ret; + return WpaCliCmd(cmd, buf, sizeof(buf)); } -WifiWpaInterface *GetWifiWpaGlobalInterface(void) +void InitWifiWpaGlobalInterface(void) { - pthread_mutex_lock(&g_mutex); - - HDF_LOGI("enter GetWifiWpaGlobalInterface."); + HDF_LOGI("enter InitWifiWpaGlobalInterface."); if (g_wpaInterface != NULL) { - pthread_mutex_unlock(&g_mutex); - return g_wpaInterface; + return; } g_wpaInterface = (WifiWpaInterface *)calloc(1, sizeof(WifiWpaInterface)); if (g_wpaInterface == NULL) { - pthread_mutex_unlock(&g_mutex); HDF_LOGE("Failed to create wpa interface!"); - return NULL; + return; } g_wpaInterface->wpaCliConnect = WpaCliConnect; g_wpaInterface->wpaCliClose = WpaCliClose; - g_wpaInterface->wpaCliAddIface = WpaCliAddIface; g_wpaInterface->wpaCliRemoveIface = WpaCliRemoveIface; g_wpaInterface->wpaCliTerminate = WpaCliWpaTerminate; g_wpaInterface->ifaces = NULL; - pthread_mutex_unlock(&g_mutex); +} + +WifiWpaInterface *GetWifiWpaGlobalInterface(void) +{ + HDF_LOGI("enter GetWifiWpaGlobalInterface."); return g_wpaInterface; } -- Gitee From fee0d84cce54438201903ec16137336601c0bb81 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:56:22 +0000 Subject: [PATCH 0288/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h index 058232d659..5abc8eed60 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.h @@ -28,7 +28,6 @@ extern "C" { #endif - #define WIFI_CONF_FILE_PATH_LEN 256 typedef struct AddInterfaceArgv { @@ -51,7 +50,6 @@ struct StWifiWpaInterface { pthread_t tid; int threadRunFlag; WpaIfaceInfo *ifaces; - int (*wpaCliConnect)(WifiWpaInterface *p); void (*wpaCliClose)(WifiWpaInterface *p); int (*wpaCliAddIface)(WifiWpaInterface *p, const AddInterfaceArgv *argv, bool isWpaAdd); @@ -66,6 +64,7 @@ WpaCtrl *GetP2pCtrl(void); WpaCtrl *GetChbaCtrl(void); WpaCtrl *GetCommonCtrl(void); void ReleaseIfaceCtrl(char *ifName, int len); +void InitWifiWpaGlobalInterface(void); #ifdef __cplusplus } -- Gitee From d708d153f8ffe828825125be996d9207836c426a Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 09:57:54 +0000 Subject: [PATCH 0289/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h. Signed-off-by: xionglei --- .../hdi_service/service_common/test.c | 1220 ---------------- .../hdi_service/service_common/test2.c | 1065 -------------- .../hdi_service/service_common/test3.c | 1239 ----------------- .../hdi_service/service_common/test4.c | 1177 ---------------- .../hdi_service/service_common/test5.c | 0 .../service_common/wpa_common_cmd.c | 211 ++- .../service_common/wpa_common_cmd.h | 3 +- .../hdi_service/service_common/wpa_p2p_cmd.c | 252 +++- 8 files changed, 396 insertions(+), 4771 deletions(-) delete mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test.c delete mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test2.c delete mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test3.c delete mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test4.c delete mode 100644 wlan/wpa/interfaces/hdi_service/service_common/test5.c diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test.c b/wlan/wpa/interfaces/hdi_service/service_common/test.c deleted file mode 100644 index 87c0e76faf..0000000000 --- a/wlan/wpa/interfaces/hdi_service/service_common/test.c +++ /dev/null @@ -1,1220 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "wpa_common_cmd.h" -#include "wpa_p2p_cmd.h" -#include "hdi_wpa_hal.h" -#include -#include -#include -#include -#include -#include -#include "utils/common.h" -#include "wpa_supplicant_i.h" -#include "ctrl_iface.h" -#include "main.h" -#include "wps_supplicant.h" -#include "bssid_ignore.h" -#include "wpa_supplicant/config.h" -#include "common/defs.h" -#include "v1_1/iwpa_callback.h" -#include "v1_1/iwpa_interface.h" -#include "wpa_client.h" -#include -#include -#include -#include -#include "hdi_wpa_common.h" - -#define BUF_SIZE 512 - -pthread_t g_tid; -const int QUOTATION_MARKS_FLAG_YES = 0; -const int QUOTATION_MARKS_FLAG_NO = 1; -const int MAX_NETWORKS_NUM = 100; -pthread_mutex_t g_interfaceLock = PTHREAD_MUTEX_INITIALIZER; - -static WpaSsidField g_wpaSsidFields[] = { - {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_PSK, "psk", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_KEYMGMT, "key_mgmt", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_PRIORITY, "priority", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_SCAN_SSID, "scan_ssid", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_EAP, "eap", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_IDENTITY, "identity", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_PASSWORD, "password", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_BSSID, "bssid", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_AUTH_ALGORITHMS, "auth_alg", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_IDX, "wep_tx_keyidx", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_0, "wep_key0", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_1, "wep_key1", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_2, "wep_key2", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_3, "wep_key3", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_EAP_CLIENT_CERT, "client_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_EAP_PRIVATE_KEY, "private_key", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_EAP_PHASE2METHOD, "phase2", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_IEEE80211W, "ieee80211w", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_ALLOW_PROTOCOLS, "proto", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_GROUP_CIPHERS, "group", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_PAIRWISE_CIPHERS, "pairwise", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_SAE_PASSWD, "sae_password", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_CA_CERT, "wapi_ca_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_USER_CERT, "wapi_user_sel_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_PSK_KEY_TYPE, "psk_key_type", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WAPI_PSK, "wapi_psk", QUOTATION_MARKS_FLAG_YES}, -}; - -int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH]) -{ - int flag = g_wpaSsidFields[pos].flag; - const int hexPskMaxLen = 64; - int len = strlen(value); - /* if the psk length is 64, it's hex format and don't need quotation marks */ - if (pos == DEVICE_CONFIG_PSK && len >= hexPskMaxLen) { - flag = QUOTATION_MARKS_FLAG_NO; - } - if (pos == DEVICE_CONFIG_WEP_KEY_0 || - pos == DEVICE_CONFIG_WEP_KEY_1 || - pos == DEVICE_CONFIG_WEP_KEY_2 || - pos == DEVICE_CONFIG_WEP_KEY_3) { - const int wepKeyLen1 = 5; - const int wepKeyLen2 = 13; - const int wepKeyLen3 = 16; - /* For wep key, ASCII format need quotation marks, hex format is not required */ - if (len == wepKeyLen1 || len == wepKeyLen2 || len == wepKeyLen3) { - flag = QUOTATION_MARKS_FLAG_YES; - } - } - return flag; -} - -pthread_mutex_t *GetInterfaceLock() -{ - return &g_interfaceLock; -} - -int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) -{ - if (src == NULL || dst == NULL || dstLen == NULL) { - HDF_LOGE("%{public}s: Invalid parameter!", __func__); - return HDF_ERR_INVALID_PARAM; - } - HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); - if (srcLen > 0) { - *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); - if (*dst == NULL) { - HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); - return HDF_FAILURE; - } - if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { - HDF_LOGE("%{public}s: memcpy_s fail!", __func__); - return HDF_FAILURE; - } - } - *dstLen = srcLen; - return HDF_SUCCESS; -} - -struct HdfWpaStubData *HdfWpaStubDriver(void) -{ - static struct HdfWpaStubData registerManager; - return ®isterManager; -} - -int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - ScanSettings settings = {0}; - settings.scanStyle = SCAN_TYPE_LOW_SPAN; - int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - if (ret == WIFI_HAL_SCAN_BUSY) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan return scan busy", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: StartScan successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, - uint32_t *resultBufLen) -{ - HDF_LOGI("enter %{public}s", __func__); - (void)self; - if (ifName == NULL || resultBuf == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: Get scan result successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - if (ifName == NULL || networkId == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - *networkId = ret; - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId, const char *name, const char *value) -{ - (void)self; - if (ifName == NULL || name == NULL || value == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - HDF_LOGI("enter %{public}s networkId = %{public}d name = %{private}s value = %{private}s", __func__, networkId, - name, value); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaSetNetworkArgv conf = {0}; - conf.id = networkId; - int pos = -1; - for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { - if (strcmp(g_wpaSsidFields[i].fieldName, name) == 0) { - pos = i; - conf.param = g_wpaSsidFields[i].field; - break; - } - } - if (pos < 0) { - HDF_LOGE("%{public}s SetNetwork: unsupported name %{public}s", __func__, name); - return HDF_FAILURE; - } - if (strncpy_s(conf.value, sizeof(conf.value), value, strlen(value)) != 0) { - HDF_LOGE("%{public}s strncpy_s conf.value fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetNetwork(pStaIfc, &conf); - if (ret < 0) { - HDF_LOGE("%{public}s: wpaCliCmdSetNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - HDF_LOGI("%{public}s: wpaCliCmdSetNetwork sucess ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) -{ - int32_t ret = HDF_SUCCESS; - - if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { - HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); - if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, - tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, - (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, - (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill flags fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWifiWpaNetworkInfo->bssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->bssid); - hdiWifiWpaNetworkInfo->bssid = NULL; - } - if (hdiWifiWpaNetworkInfo->ssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->ssid); - hdiWifiWpaNetworkInfo->ssid = NULL; - } - if (hdiWifiWpaNetworkInfo->flags != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->flags); - hdiWifiWpaNetworkInfo->flags = NULL; - } - } - return ret; -} - -//need to check -int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, - struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL || networkInfo == NULL || networkInfoLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - int size = MAX_NETWORKS_NUM; - WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(size, sizeof(WifiNetworkInfo)); - if (infos == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: info = NULL", __func__); - return HDF_FAILURE; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - free(infos); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdListNetworks(pStaIfc, infos, &size); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdListNetworks fail! ret = %{public}d", __func__, ret); - free(infos); - return HDF_FAILURE; - } - WifiNetworkInfo *infosTmp = infos; - HDF_LOGI("%{public}s: wpaCliCmdListNetworks success size = %{public}d", __func__, size); - for (int i = 0; i < ((size > MAX_NETWORKS_NUM) ? MAX_NETWORKS_NUM : size); i++) { - WpaFillWpaListNetworkParam(infos, networkInfo); - infos++; - networkInfo++; - } - *networkInfoLen = size; - free(infosTmp); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSelectNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSelectNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSelectNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdEnableNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdEnableNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdEnableNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdReconnect(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdReconnect fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdReconnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdDisconnect(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdDisconnect fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdDisconnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, const int32_t enable) -{ - (void)self; - HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdPowerSave(pStaIfc, enable); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdPowerSave fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdPowerSave success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) -{ - (void)self; - HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetAutoConnect(pStaIfc, enable); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSetAutoConnect fail! ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSetAutoConnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) -{ - if (halStatus == NULL) { - HDF_LOGE("%{public}s halStatus is NULL", __func__); - return; - } - status->id = halStatus->id; - status->freq = halStatus->freq; - if (strcmp(halStatus->keyMgmt, "") != 0) { - HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); - status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); - if (status->keyMgmt == NULL) { - HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); - status->keyMgmtLen = 0; - return; - } - status->keyMgmtLen = strlen(halStatus->keyMgmt); - if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->ssid, "") != 0) { - HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); - status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); - if (status->ssid == NULL) { - HDF_LOGE("%{public}s status->ssid is NULL", __func__); - status->ssidLen = 0; - return; - } - status->ssidLen = strlen(halStatus->ssid); - if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->address, "") != 0) { - HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); - uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->address, tmpAddress); - status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->address == NULL) { - HDF_LOGE("%{public}s status->address is NULL", __func__); - status->addressLen = 0; - return; - } - status->addressLen = ETH_ADDR_LEN + 1 ; - if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { - HDF_LOGE("%{public}s strcpy memcpy", __func__); - } - } - if (strcmp(halStatus->bssid, "") != 0) { - HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); - uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->bssid, tmpBssid); - status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->bssid == NULL) { - HDF_LOGE("%{public}s status->bssid is NULL", __func__); - status->bssidLen = 0; - return; - } - status->bssidLen = ETH_ADDR_LEN + 1 ; - if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } -} - -int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) -{ - HDF_LOGI("enter %{public}s", __func__); - if (ifName == NULL || status == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaHalCmdStatus halStatus; - if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - status->bssidLen = 0; - status->ssidLen = 0; - status->keyMgmtLen = 0; - status->addressLen = 0; - WpaProcessWifiStatus(&halStatus, status); - if (status->addressLen == 0) { - HDF_LOGE("%{public}s key not include address", __func__); - } - if (status->bssidLen == 0) { - HDF_LOGE("%{public}s key not include bssid", __func__); - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -const char *macToStr(const u8 *addr) -{ - const int macAddrIndexOne = 0; - const int macAddrIndexTwo = 1; - const int macAddrIndexThree = 2; - const int macAddrIndexFour = 3; - const int macAddrIndexFive = 4; - const int macAddrIndexSix = 5; - static char macToStr[WIFI_BSSID_LENGTH]; - if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", - addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], - addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { - return NULL; - } - return macToStr; -} - -int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret; - if (wpaParam->anyFlag < 0 && wpaParam->multiAp <= 0 && wpaParam->bssidLen == 0) { - ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, NULL); - } else { - struct WpaWpsPbcArgv config = {0}; - config.anyFlag = wpaParam->anyFlag; - config.multiAp = wpaParam->multiAp; - if (wpaParam->bssidLen > 0) { - if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, - wpaParam->bssidLen) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); - return HDF_FAILURE; - } - } - ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); - } - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } else if (ret == WIFI_HAL_PBC_OVERLAP) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, - const struct HdiWifiWpsParam *wpaParam, int *pinCode) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL - || wpaParam->pinCode == NULL || pinCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaWpsPinArgv config = {{0}, {0}}; - if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), - strlen(macToStr(wpaParam->bssid))) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - - int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -//need to deal countryCodeLen -int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName, - char *countryCode, uint32_t countryCodeLen) -{ - HDF_LOGI("enter %{public}s: ", __func__); - (void)self; - if (ifName == NULL || countryCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -//need to deal valueLen -int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId, const char *param, char *value, uint32_t valueLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || param == NULL || value == NULL || valueLen == 0) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaGetNetworkArgv getNetwork = {0}; - getNetwork.id = networkId; - if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s param fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode) -{ - HDF_LOGI("enter %{public}s: mode = %{public}d", __func__, mode); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName, - struct ConnectionCapabilities *connectionCap) -{ - HDF_LOGI("enter %{public}s: ", __func__); - (void)self; - if (ifName == NULL || connectionCap == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || enable == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int scanSsid = 0; - int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - *enable = (scanSsid == 1); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName, - char *psk, uint32_t pskLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || psk == NULL || pskLen == 0) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || psk == NULL || pskLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx, - uint8_t *wepKey, uint32_t *wepKeyLen) -{ - HDF_LOGI("enter %{public}s keyIdx = %{public}d", __func__, keyIdx); - (void)self; - if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || keyIdx == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || enable == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || countryCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) -{ - HDF_LOGI("enter %{public}s ", __func__); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); - return; - } - int ret = pWpaInterface->wpaCliTerminate(); - if (ret != 0) { - HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); - } else { - HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); - } - ReleaseWpaGlobalInterface(); - HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); -} - -static struct RemoteServiceDeathRecipient g_deathRecipient = { - .recipient = { - .OnRemoteDied = OnRemoteServiceDied, - } -}; - -static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) -{ - HDF_LOGI("enter %{public}s ", __func__); - if (cbFunc == NULL) { - HDF_LOGE("invalid parameter"); - return; - } - struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); - if (remote == NULL) { - HDF_LOGE("remote is NULL"); - return; - } - HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); -} - -static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - if (self == NULL) { - HDF_LOGE("%{public}s:self == NULL", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (!DListIsEmpty(head)) { - DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { - if (pos->service == self->AsObject(self)) { - HDF_LOGE("%{public}s: pos->service == self", __func__); - return HDF_FAILURE; - } - } - } - struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); - if (newRemoteNode == NULL) { - HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); - return HDF_FAILURE; - } - newRemoteNode->callbackObj = self; - newRemoteNode->service = self->AsObject(self); - DListInsertTail(&newRemoteNode->node, head); - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - AddDeathRecipientForService(self); - } - return HDF_SUCCESS; -} \ No newline at end of file diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test2.c b/wlan/wpa/interfaces/hdi_service/service_common/test2.c deleted file mode 100644 index 5604e93f0f..0000000000 --- a/wlan/wpa/interfaces/hdi_service/service_common/test2.c +++ /dev/null @@ -1,1065 +0,0 @@ -static void HdfWpaDelRemoteObj(struct IWpaCallback *self) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct HdfWpaRemoteNode *tmp = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { - if (pos->service->index == self->AsObject(self)->index) { - DListRemove(&(pos->node)); - IWpaCallbackRelease(pos->callbackObj); - OsalMemFree(pos); - pos = NULL; - break; - } - } - IWpaCallbackRelease(self); -} - -static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { - HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; - hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; - if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, - disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaDisconnectParam->bssid != NULL) { - OsalMemFree(hdiWpaDisconnectParam->bssid); - hdiWpaDisconnectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, - struct HdiWpaConnectParam *hdiWpaConnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (connectParam == NULL || hdiWpaConnectParam == NULL) { - HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaConnectParam->networkId = connectParam->networkId; - if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, - connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaConnectParam->bssid != NULL) { - OsalMemFree(hdiWpaConnectParam->bssid); - hdiWpaConnectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) -{ - int32_t ret = HDF_SUCCESS; - - if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { - HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, - bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, - bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill reason fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaBssidChangedParam->bssid != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->bssid); - hdiWpaBssidChangedParam->bssid = NULL; - } - if (hdiWpaBssidChangedParam->reason != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->reason); - hdiWpaBssidChangedParam->reason = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam, - struct HdiWpaStateChangedParam *hdiWpaStateChangedParam) -{ - int32_t ret = HDF_SUCCESS; - - if (stateChangedParam == NULL || hdiWpaStateChangedParam == NULL) { - HDF_LOGE("%{public}s: stateChangedParam or hdiWpaStateChangedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaStateChangedParam->networkId = stateChangedParam->networkId; - HDF_LOGD("%{public}s: hdiWpaStateChangedParam->networkId =%d", __func__, hdiWpaStateChangedParam->networkId); - hdiWpaStateChangedParam->status = stateChangedParam->status; - HDF_LOGD("%{public}s: hdiWpaStateChangedParam->status =%d", __func__, hdiWpaStateChangedParam->status); - do { - HDF_LOGD("%{public}s: stateChangedParam->bssid[0] = %x", __func__, stateChangedParam->bssid[0]); - HDF_LOGD("%{public}s: stateChangedParam->bssid[5] = %x", __func__, - stateChangedParam->bssid[WIFI_BSSID_LEN - 1]); - if (FillData(&hdiWpaStateChangedParam->bssid, &hdiWpaStateChangedParam->bssidLen, - stateChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - HDF_LOGD("%{public}s: stateChangedParam->ssid[0] = %x", __func__, stateChangedParam->ssid[0]); - HDF_LOGD("%{public}s: stateChangedParam->ssid[WIFI_SSID_LENGTH-1] = %x", __func__, - stateChangedParam->ssid[WIFI_SSID_LENGTH - 1]); - if (memcmp(stateChangedParam->ssid, "\0", 1) == 0) { - hdiWpaStateChangedParam->ssidLen = 0; - HDF_LOGE("%{public}s: hdiWpaStateChangedParam->ssidLen =%d", __func__, hdiWpaStateChangedParam->ssidLen); - } else { - if (FillData(&hdiWpaStateChangedParam->ssid, &hdiWpaStateChangedParam->ssidLen, - stateChangedParam->ssid, strlen((char*)stateChangedParam->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaStateChangedParam->bssid != NULL) { - OsalMemFree(hdiWpaStateChangedParam->bssid); - hdiWpaStateChangedParam->bssid = NULL; - } - if (hdiWpaStateChangedParam->ssid != NULL) { - OsalMemFree(hdiWpaStateChangedParam->ssid); - hdiWpaStateChangedParam->ssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaTempDisabledParam(struct WpaTempDisabledParam *tempDisabledParam, - struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam) -{ - int32_t ret = HDF_SUCCESS; - - if (tempDisabledParam == NULL || hdiWpaTempDisabledParam == NULL) { - HDF_LOGE("%{public}s: tempDisabledParam or hdiWpaTempDisabledParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaTempDisabledParam->networkId = tempDisabledParam->networkId; - hdiWpaTempDisabledParam->authFailures = tempDisabledParam->authFailures; - hdiWpaTempDisabledParam->duration = tempDisabledParam->duration; - do { - if (FillData(&hdiWpaTempDisabledParam->reason, &hdiWpaTempDisabledParam->reasonLen, - tempDisabledParam->reason, strlen((char*)tempDisabledParam->reason)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWpaTempDisabledParam->ssid, &hdiWpaTempDisabledParam->ssidLen, - tempDisabledParam->ssid, strlen((char*)tempDisabledParam->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaTempDisabledParam->reason != NULL) { - OsalMemFree(hdiWpaTempDisabledParam->reason); - hdiWpaTempDisabledParam->reason = NULL; - } - if (hdiWpaTempDisabledParam->ssid != NULL) { - OsalMemFree(hdiWpaTempDisabledParam->ssid); - hdiWpaTempDisabledParam->ssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaAssociateRejectParam(struct WpaAssociateRejectParam *associateRejectParam, - struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (associateRejectParam == NULL || hdiWpaAssociateRejectParam == NULL) { - HDF_LOGE("%{public}s: associateRejectParam or hdiWpaAssociateRejectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaAssociateRejectParam->statusCode = associateRejectParam->statusCode; - hdiWpaAssociateRejectParam->timeOut = associateRejectParam->timeOut; - if (FillData(&hdiWpaAssociateRejectParam->bssid, &hdiWpaAssociateRejectParam->bssidLen, - associateRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaAssociateRejectParam->bssid != NULL) { - OsalMemFree(hdiWpaAssociateRejectParam->bssid); - hdiWpaAssociateRejectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaRecvScanResultParam(struct WpaRecvScanResultParam *recvScanResultParam, - struct HdiWpaRecvScanResultParam *hdiWpaRecvScanResultParam) -{ - int32_t ret = HDF_SUCCESS; - - if (recvScanResultParam == NULL || hdiWpaRecvScanResultParam == NULL) { - HDF_LOGE("%{public}s: recvScanResultParam or hdiWpaRecvScanResultParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaRecvScanResultParam->scanId = recvScanResultParam->scanId; - return ret; -} - -static int32_t WpaFillWpaAuthRejectParam(struct WpaAuthRejectParam *authRejectParam, - struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (authRejectParam == NULL || hdiWpaAuthRejectParam == NULL) { - HDF_LOGE("%{public}s: authRejectParam or hdiWpaAuthRejectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaAuthRejectParam->statusCode = authRejectParam->statusCode; - hdiWpaAuthRejectParam->authType = authRejectParam->authType; - hdiWpaAuthRejectParam->authTransaction = authRejectParam->authTransaction; - if (FillData(&hdiWpaAuthRejectParam->bssid, &hdiWpaAuthRejectParam->bssidLen, - authRejectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaAuthRejectParam->bssid != NULL) { - OsalMemFree(hdiWpaAuthRejectParam->bssid); - hdiWpaAuthRejectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t ProcessEventWpaDisconnect(struct HdfWpaRemoteNode *node, - struct WpaDisconnectParam *disconnectParam, const char *ifName) -{ - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDisconnected == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaDisconnectParam = (struct HdiWpaDisconnectParam *)OsalMemCalloc(sizeof(struct HdiWpaDisconnectParam)); - if ((hdiWpaDisconnectParam == NULL) || (WpaFillWpaDisconnectParam(disconnectParam, - hdiWpaDisconnectParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaDisconnectParam is NULL or disconnectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventDisconnected(node->callbackObj, hdiWpaDisconnectParam, ifName); - } - HdiWpaDisconnectParamFree(hdiWpaDisconnectParam, true); - return ret; -} - -static int32_t ProcessEventWpaConnect(struct HdfWpaRemoteNode *node, - struct WpaConnectParam *connectParam, const char *ifName) -{ - struct HdiWpaConnectParam *hdiWpaConnectParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventConnected == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaConnectParam = (struct HdiWpaConnectParam *)OsalMemCalloc(sizeof(struct HdiWpaConnectParam)); - if ((hdiWpaConnectParam == NULL) || (WpaFillWpaConnectParam(connectParam, hdiWpaConnectParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: HdiWpaConnectParam is NULL or connectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventConnected(node->callbackObj, hdiWpaConnectParam, ifName); - } - HdiWpaConnectParamFree(hdiWpaConnectParam, true); - return ret; -} - -static int32_t ProcessEventWpaBssidChange(struct HdfWpaRemoteNode *node, - struct WpaBssidChangedParam *bssidChangeParam, const char *ifName) -{ - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam = NULL; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventBssidChanged == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaBssidChangedParam = (struct HdiWpaBssidChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaBssidChangedParam)); - if ((hdiWpaBssidChangedParam == NULL) || (WpaFillWpaBssidChangedParam(bssidChangeParam, - hdiWpaBssidChangedParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaBssidChangedParam is NULL or bssidChangeParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventBssidChanged(node->callbackObj, hdiWpaBssidChangedParam, ifName); - } - HdiWpaBssidChangedParamFree(hdiWpaBssidChangedParam, true); - return ret; -} - -static int32_t ProcessEventWpaStateChange(struct HdfWpaRemoteNode *node, - struct WpaStateChangedParam *stateChangeParam, const char *ifName) -{ - struct HdiWpaStateChangedParam *hdiWpaStateChangedParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStateChanged == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaStateChangedParam = (struct HdiWpaStateChangedParam *)OsalMemCalloc(sizeof(struct HdiWpaStateChangedParam)); - if ((hdiWpaStateChangedParam == NULL) || (WpaFillWpaStateChangedParam(stateChangeParam, - hdiWpaStateChangedParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaStateChangedParam is NULL or stateChangeParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventStateChanged(node->callbackObj, hdiWpaStateChangedParam, ifName); - } - HdiWpaStateChangedParamFree(hdiWpaStateChangedParam, true); - return ret; -} - -static int32_t ProcessEventWpaTempDisable(struct HdfWpaRemoteNode *node, - struct WpaTempDisabledParam *tempDisabledParam, const char *ifName) -{ - struct HdiWpaTempDisabledParam *hdiWpaTempDisabledParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventTempDisabled == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaTempDisabledParam = (struct HdiWpaTempDisabledParam *)OsalMemCalloc(sizeof(struct HdiWpaTempDisabledParam)); - if ((hdiWpaTempDisabledParam == NULL) || (WpaFillWpaTempDisabledParam(tempDisabledParam, - hdiWpaTempDisabledParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaTempDisabledParam is NULL or tempDisabledParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventTempDisabled(node->callbackObj, hdiWpaTempDisabledParam, ifName); - } - HdiWpaTempDisabledParamFree(hdiWpaTempDisabledParam, true); - return ret; -} - -static int32_t ProcessEventWpaAssociateReject(struct HdfWpaRemoteNode *node, - struct WpaAssociateRejectParam *associateRejectParam, const char *ifName) -{ - struct HdiWpaAssociateRejectParam *hdiWpaAssociateRejectParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAssociateReject == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaAssociateRejectParam = (struct HdiWpaAssociateRejectParam *) - OsalMemCalloc(sizeof(struct HdiWpaAssociateRejectParam)); - if ((hdiWpaAssociateRejectParam == NULL) || (WpaFillWpaAssociateRejectParam(associateRejectParam, - hdiWpaAssociateRejectParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventAssociateReject(node->callbackObj, hdiWpaAssociateRejectParam, ifName); - } - HdiWpaAssociateRejectParamFree(hdiWpaAssociateRejectParam, true); - return ret; -} - -static int32_t ProcessEventWpaWpsOverlap(struct HdfWpaRemoteNode *node, - const char *ifName) -{ - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - ret = node->callbackObj->OnEventWpsOverlap(node->callbackObj, ifName); - return ret; -} - -static int32_t ProcessEventWpaWpsTimeout(struct HdfWpaRemoteNode *node, - const char *ifName) -{ - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - ret = node->callbackObj->OnEventWpsTimeout(node->callbackObj, ifName); - return ret; -} - -static int32_t ProcessEventWpaAuthTimeout(struct HdfWpaRemoteNode *node, const char *ifName) -{ - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - ret = node->callbackObj->OnEventAuthTimeout(node->callbackObj, ifName); - return ret; -} - -static int32_t ProcessEventWpaRecvScanResult(struct HdfWpaRemoteNode *node, - struct WpaRecvScanResultParam *recvScanResultParam, const char *ifName) -{ - struct HdiWpaRecvScanResultParam *hdiRecvScanResultParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventScanResult == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiRecvScanResultParam = (struct HdiWpaRecvScanResultParam *) - OsalMemCalloc(sizeof(struct HdiWpaRecvScanResultParam)); - if ((hdiRecvScanResultParam == NULL) || (WpaFillWpaRecvScanResultParam(recvScanResultParam, - hdiRecvScanResultParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaAssociateRejectParam is NULL or associateRejectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventScanResult(node->callbackObj, hdiRecvScanResultParam, ifName); - } - HdiWpaRecvScanResultParamFree(hdiRecvScanResultParam, true); - return ret; -} - -static int32_t ProcessEventWpaAuthReject( - struct HdfWpaRemoteNode *node, struct WpaAuthRejectParam *authRejectParam, const char *ifName) -{ - struct HdiWpaAuthRejectParam *hdiWpaAuthRejectParam = NULL; - int32_t ret = HDF_FAILURE; - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventAuthReject == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaAuthRejectParam = - (struct HdiWpaAuthRejectParam *)OsalMemCalloc(sizeof(struct HdiWpaAuthRejectParam)); - if ((hdiWpaAuthRejectParam == NULL) || - (WpaFillWpaAuthRejectParam(authRejectParam, hdiWpaAuthRejectParam) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiWpaAuthRejectParam is NULL or authRejectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventAuthReject(node->callbackObj, hdiWpaAuthRejectParam, ifName); - } - HdiWpaAuthRejectParamFree(hdiWpaAuthRejectParam, true); - return ret; -} - -int32_t ProcessEventStaNotify(struct HdfWpaRemoteNode *node, char *notifyParam, const char *ifName) -{ - int32_t ret = HDF_FAILURE; - if (notifyParam == NULL || ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_FAILURE; - } - char *notifyStr = (char*)malloc(BUF_SIZE); - if (notifyStr == NULL) { - HDF_LOGE("%{public}s notifyStr malloc failed", __func__); - return HDF_FAILURE; - } - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaNotify == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - free(notifyStr); - return HDF_ERR_INVALID_PARAM; - } - if (memset_s(notifyStr, BUF_SIZE, 0, BUF_SIZE) != EOK) { - HDF_LOGE("%{public}s memset failed", __func__); - free(notifyStr); - return HDF_FAILURE; - } - if (strcpy_s(notifyStr, BUF_SIZE, notifyParam) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - free(notifyStr); - return HDF_FAILURE; - } - ret = node->callbackObj->OnEventStaNotify(node->callbackObj, notifyStr, ifName); - free(notifyStr); - return ret; -} - -static int32_t WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo *wpaVendorExtInfo, - struct WpaVendorInfo *wpaVendorInfo) -{ - if (wpaVendorExtInfo == NULL || wpaVendorInfo == NULL) { - HDF_LOGE("%{public}s: wpaVendorExtInfo or wpaVendorInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - - wpaVendorInfo->type = wpaVendorExtInfo->type; - wpaVendorInfo->freq = wpaVendorExtInfo->freq; - wpaVendorInfo->width = wpaVendorExtInfo->width; - wpaVendorInfo->id = wpaVendorExtInfo->id; - wpaVendorInfo->status = wpaVendorExtInfo->status; - wpaVendorInfo->reason = wpaVendorExtInfo->reason; - if (FillData(&wpaVendorInfo->ssid, &wpaVendorInfo->ssidLen, - wpaVendorExtInfo->ssid, strlen((char *)wpaVendorExtInfo->ssid)) != EOK) { - HDF_LOGE("%{public}s: memcpy_s ssid fail !", __func__); - return HDF_FAILURE; - } - - if (FillData(&wpaVendorInfo->psk, &wpaVendorInfo->pskLen, - wpaVendorExtInfo->psk, strlen((char *)wpaVendorExtInfo->psk)) != EOK) { - HDF_LOGE("%{public}s: memcpy_s psk fail !", __func__); - return HDF_FAILURE; - } - - if (FillData(&wpaVendorInfo->devAddr, &wpaVendorInfo->devAddrLen, - wpaVendorExtInfo->devAddr, ETH_ADDR_LEN) != EOK) { - HDF_LOGE("%{public}s: memcpy_s devAddr fail !", __func__); - return HDF_FAILURE; - } - - if (FillData(&wpaVendorInfo->data, &wpaVendorInfo->dataLen, - wpaVendorExtInfo->data, strlen((char *)wpaVendorExtInfo->data)) != EOK) { - HDF_LOGE("%{public}s: memcpy_s data fail !", __func__); - return HDF_FAILURE; - } - - HDF_LOGI("wpaVendorInfo type %{public}d, freq %{public}d, reason %{public}d, " - "id %{public}d status %{public}d!", - wpaVendorInfo->type, wpaVendorInfo->freq, wpaVendorInfo->reason, - wpaVendorInfo->id, wpaVendorInfo->status); - return HDF_SUCCESS; -} - -static int32_t ProcessEventWpaVendorExt(struct HdfWpaRemoteNode *node, - struct WpaVendorExtInfo *wpaVendorExtInfo, const char *ifName) -{ - HDF_LOGI("%{public}s: ifName => %{public}s ; ", __func__, ifName); - struct WpaVendorInfo wpaVendorInfo; - int32_t ret = HDF_FAILURE; - if (wpaVendorExtInfo == NULL) { - HDF_LOGE("%{public}s: wpaVendorExtInfo is NULL !", __func__); - return HDF_ERR_INVALID_PARAM; - } - - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventVendorCb == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - - if (WpaFillWpaVendorExtInfo(wpaVendorExtInfo, &wpaVendorInfo) != HDF_SUCCESS) { - ret = HDF_FAILURE; - HDF_LOGE("%{public}s: wpaVendorInfo is NULL or associateRejectParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventVendorCb(node->callbackObj, &wpaVendorInfo, ifName); - } - HDF_LOGI("%{public}s: res %{public}d!", __func__, ret); - return ret; -} -static int32_t HdfStaDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) -{ - int32_t ret = HDF_FAILURE; - switch (event) { - case WPA_EVENT_DISCONNECT: - ret = ProcessEventWpaDisconnect(pos, (struct WpaDisconnectParam *)data, ifName); - break; - case WPA_EVENT_CONNECT: - ret = ProcessEventWpaConnect(pos, (struct WpaConnectParam *)data, ifName); - break; - case WPA_EVENT_BSSID_CHANGE: - ret = ProcessEventWpaBssidChange(pos, (struct WpaBssidChangedParam *)data, ifName); - break; - case WPA_EVENT_STATE_CHANGED: - ret = ProcessEventWpaStateChange(pos, (struct WpaStateChangedParam *)data, ifName); - break; - case WPA_EVENT_TEMP_DISABLE: - ret = ProcessEventWpaTempDisable(pos, (struct WpaTempDisabledParam *)data, ifName); - break; - case WPA_EVENT_ASSOCIATE_REJECT: - ret = ProcessEventWpaAssociateReject(pos, (struct WpaAssociateRejectParam *)data, ifName); - break; - case WPA_EVENT_WPS_OVERLAP: - ret = ProcessEventWpaWpsOverlap(pos, ifName); - break; - case WPA_EVENT_WPS_TIMEMOUT: - ret = ProcessEventWpaWpsTimeout(pos, ifName); - break; - case WPA_EVENT_AUTH_TIMEOUT: - ProcessEventWpaAuthTimeout(pos, ifName); - break; - case WPA_EVENT_RECV_SCAN_RESULT: - ret = ProcessEventWpaRecvScanResult(pos, (struct WpaRecvScanResultParam *)data, ifName); - break; - case WPA_EVENT_STA_AUTH_REJECT: - ret = ProcessEventWpaAuthReject(pos, (struct WpaAuthRejectParam *)data, ifName); - break; - case WPA_EVENT_STA_NOTIFY: - ret = ProcessEventStaNotify(pos, (char *)data, ifName); - break; - default: - HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); - break; - } - return ret; -} - -static int32_t HdfP2pDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) -{ - int32_t ret = HDF_FAILURE; - switch (event) { - case WPA_EVENT_DEVICE_FOUND: - ret = ProcessEventP2pDeviceFound(pos, (struct P2pDeviceInfoParam *)data, ifName); - break; - case WPA_EVENT_DEVICE_LOST: - ret = ProcessEventP2pDeviceLost(pos, (struct P2pDeviceLostParam *)data, ifName); - break; - case WPA_EVENT_GO_NEGOTIATION_REQUEST: - ret = ProcessEventP2pGoNegotiationRequest(pos, (struct P2pGoNegotiationRequestParam *)data, ifName); - break; - case WPA_EVENT_GO_NEGOTIATION_COMPLETED: - ret = ProcessEventP2pGoNegotiationCompleted(pos, (struct P2pGoNegotiationCompletedParam *)data, ifName); - break; - case WPA_EVENT_INVITATION_RECEIVED: - ret = ProcessEventP2pInvitationReceived(pos, (struct P2pInvitationReceivedParam *)data, ifName); - break; - case WPA_EVENT_INVITATION_RESULT: - ret = ProcessEventP2pInvitationResult(pos, (struct P2pInvitationResultParam *)data, ifName); - break; - case WPA_EVENT_GROUP_FORMATION_SUCCESS: - ret = ProcessEventP2pGroupFormationSuccess(pos, ifName); - break; - case WPA_EVENT_GROUP_FORMATION_FAILURE: - ret = ProcessEventP2pGroupFormationFailure(pos, (char *)data, ifName); - break; - case WPA_EVENT_GROUP_START: - ret = ProcessEventP2pGroupStarted(pos, (struct P2pGroupStartedParam *)data, ifName); - break; - case WPA_EVENT_GROUP_REMOVED: - ret = ProcessEventP2pGroupRemoved(pos, (struct P2pGroupRemovedParam *)data, ifName); - break; - case WPA_EVENT_PROVISION_DISCOVERY_COMPLETED: - ret = ProcessEventP2pProvisionDiscoveryCompleted(pos, (struct P2pProvisionDiscoveryCompletedParam *)data, - ifName); - break; - case WPA_EVENT_FIND_STOPPED: - ret = ProcessEventP2pFindStopped(pos, ifName); - break; - case WPA_EVENT_SERV_DISC_REQ: - ret = ProcessEventP2pServDiscReq(pos, (struct P2pServDiscReqInfoParam *)data, ifName); - break; - case WPA_EVENT_SERV_DISC_RESP: - ret = ProcessEventP2pServDiscResp(pos, (struct P2pServDiscRespParam *)data, ifName); - break; - case WPA_EVENT_STA_CONNECT_STATE: - ret = ProcessEventP2pStaConnectState(pos, (struct P2pStaConnectStateParam *)data, ifName); - break; - case WPA_EVENT_IFACE_CREATED: - ret = ProcessEventP2pIfaceCreated(pos, (struct P2pIfaceCreatedParam *)data, ifName); - break; - case WPA_EVENT_STA_NOTIFY: - ret = ProcessEventStaNotify(pos, (char *)data, ifName); - break; - default: - HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); - break; - } - return ret; -} - -static int32_t HdfVendorExtDealEvent(uint32_t event, struct HdfWpaRemoteNode *pos, void *data, const char *ifName) -{ - int32_t ret = HDF_FAILURE; - switch (event) { - case WPA_EVENT_VENDOR_EXT: - ret = ProcessEventWpaVendorExt(pos, (struct WpaVendorExtInfo *)data, ifName); - break; - default: - HDF_LOGE("%{public}s: unknown eventId:%{public}d", __func__, event); - break; - } - return ret; -} - - -static int32_t HdfWpaCallbackFun(uint32_t event, void *data, const char *ifName) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct DListHead *head = NULL; - int32_t ret = HDF_FAILURE; - - (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); - head = &HdfWpaStubDriver()->remoteListHead; - HDF_LOGD("%s: enter HdfWpaCallbackFun event =%u", __FUNCTION__, event); - if (ifName == NULL) { - HDF_LOGE("%{public}s: data or ifName is NULL!", __func__); - (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); - return HDF_ERR_INVALID_PARAM; - } - DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { - if (pos == NULL) { - HDF_LOGE("%{public}s: pos is NULL", __func__); - break; - } - if (pos->callbackObj == NULL) { - HDF_LOGW("%{public}s: pos->callbackObj NULL", __func__); - continue; - } - if (pos->service == NULL) { - HDF_LOGW("%{public}s: pos->service NULL", __func__); - continue; - } - if (strncmp(ifName, "wlan", strlen("wlan")) == 0 || strncmp(ifName, "common", strlen("common")) == 0) { - ret = HdfStaDealEvent(event, pos, data, ifName); - } else if (strncmp(ifName, "chba", strlen("chba")) == 0 || - strncmp(ifName, "p2p-chba", strlen("p2p-chba")) == 0) { - ret = HdfVendorExtDealEvent(event, pos, data, ifName); - } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { - ret = HdfP2pDealEvent(event, pos, data, ifName); - } else { - HDF_LOGE("%{public}s: ifName is error %{public}s", __func__, ifName); - } - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: dispatch code fialed, error code: %{public}d", __func__, ret); - } - } - (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); - return ret; -} - -int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, - const char *ifName) -{ - int32_t ret = HDF_FAILURE; - - (void)self; - pthread_mutex_lock(&g_interfaceLock); - if (cbFunc == NULL || ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - int nameLen = strlen(ifName); - if (IsSockRemoved(ifName, nameLen) == 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("invalid opt"); - return HDF_FAILURE; - } - do { - HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); - ret = HdfWpaAddRemoteObj(cbFunc, ifName); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: HdfSensorAddRemoteObj false", __func__); - break; - } - ret = WpaRegisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Register failed!, error code: %{public}d", __func__, ret); - HdfWpaDelRemoteObj(cbFunc); - break; - } - } while (0); - pthread_mutex_unlock(&g_interfaceLock); - return ret; -} - -int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct IWpaCallback *cbFunc, - const char *ifName) -{ - (void)self; - pthread_mutex_lock(&g_interfaceLock); - if (cbFunc == NULL || ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - int nameLen = strlen(ifName); - if (IsSockRemoved(ifName, nameLen) == 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("invalid opt"); - return HDF_FAILURE; - } - HdfWpaDelRemoteObj(cbFunc); - if (DListIsEmpty(&HdfWpaStubDriver()->remoteListHead)) { - int32_t ret = WpaUnregisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Unregister failed!, error code: %{public}d", __func__, ret); - } - } - pthread_mutex_unlock(&g_interfaceLock); - return HDF_SUCCESS; -} - -static void SplitCmdString(const char *startCmd, struct StWpaMainParam *pParam) -{ - if (pParam == NULL) { - return; - } - if (startCmd == NULL) { - pParam->argc = 0; - return; - } - const char *p = startCmd; - int i = 0; - int j = 0; - while (*p != '\0') { - if (*p == ' ') { - if (j <= MAX_WPA_MAIN_ARGV_LEN - 1) { - pParam->argv[i][j] = '\0'; - } else { - pParam->argv[i][MAX_WPA_MAIN_ARGV_LEN - 1] = '\0'; - } - ++i; - j = 0; - if (i >= MAX_WPA_MAIN_ARGC_NUM) { - break; - } - } else { - if (j < MAX_WPA_MAIN_ARGV_LEN - 1) { - pParam->argv[i][j] = *p; - ++j; - } - } - ++p; - } - if (i >= MAX_WPA_MAIN_ARGC_NUM) { - pParam->argc = MAX_WPA_MAIN_ARGC_NUM; - } else { - pParam->argc = i + 1; - } - return; -} - - -static void *WpaThreadMain(void *p) -{ - const char *startCmd; - struct StWpaMainParam param = {0}; - char *tmpArgv[MAX_WPA_MAIN_ARGC_NUM] = {0}; - - if (p == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return NULL; - } - startCmd = (const char *)p; - SplitCmdString(startCmd, ¶m); - for (int i = 0; i < param.argc; i++) { - tmpArgv[i] = param.argv[i]; - } - int ret = wpa_main(param.argc, tmpArgv); - HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret); - return NULL; -} - -static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) -{ - int32_t ret; - - if (moduleName == NULL || startCmd == NULL) { - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_setname_np(g_tid, "WpaMainThread"); - HDF_LOGI("%{public}s: pthread_create successfully.", __func__); - usleep(WPA_SLEEP_TIME); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { - HDF_LOGE("Failed to connect to wpa!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) -{ - (void)self; - if (ifName == NULL || confName == NULL) { - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - HDF_LOGI("enter %{public}s Ready to add iface, ifName: %{public}s, confName: %{public}s", - __func__, ifName, confName); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - AddInterfaceArgv addInterface = {0}; - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/wpa_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else { - HDF_LOGE("%{public}s Wrong ifname!", __func__); - return HDF_FAILURE; - } - if (pWpaInterface->wpaCliAddIface(pWpaInterface, &addInterface, true) < 0) { - HDF_LOGE("%{public}s Failed to add wpa iface!", __func__); - return HDF_FAILURE; - } - HDF_LOGI("%{public}s Add interface finish", __func__); - return HDF_SUCCESS; -} - - -int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - HDF_LOGI("enter %{public}s Ready to Remove iface, ifName: %{public}s", __func__, ifName); - int ret = -1; - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); - return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); -} - -static int32_t StopWpaSupplicant(void) -{ - /*Do nothing here,waiting for IWpaInterfaceReleaseInstance to destroy the wpa service. */ - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); - return HDF_FAILURE; - } - int ret = pWpaInterface->wpaCliTerminate(); - if (ret != 0) { - HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); - } else { - HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); - } - return HDF_SUCCESS; -} - -int32_t WpaInterfaceStart(struct IWpaInterface *self) -{ - int32_t ret; - - (void)self; - HDF_LOGI("enter %{public}s: wpa_supplicant begin to start", __func__); - InitWifiWpaGlobalInterface(); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGI("fail get global interface"); - return HDF_FAILURE; - } - pthread_mutex_lock(&g_interfaceLock); - ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceStop(struct IWpaInterface *self) -{ - int32_t ret; - - (void)self; - pthread_mutex_lock(&g_interfaceLock); - HDF_LOGI("enter %{public}s: wpa_supplicant begin to stop", __func__); - ret = StopWpaSupplicant(); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - ReleaseWifiStaInterface(0); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdReassociate(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdReassociate fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdReassociate success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL || cmd == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdStaShellCmd(pStaIfc, cmd); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: fail ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: success", __func__); - return HDF_SUCCESS; -} diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test3.c b/wlan/wpa/interfaces/hdi_service/service_common/test3.c deleted file mode 100644 index 8f7f249411..0000000000 --- a/wlan/wpa/interfaces/hdi_service/service_common/test3.c +++ /dev/null @@ -1,1239 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "wpa_common_cmd.h" -#include "wpa_p2p_cmd.h" -#include "hdi_wpa_common.h" -#include -#include -#include -#include -#include -#include -#include "utils/common.h" -#include "wpa_supplicant_i.h" -#include "main.h" -#include "wps_supplicant.h" -#include "p2p_supplicant.h" -#include "ctrl_iface.h" -#include "wpa_magiclink.h" -#include "wifi_display.h" -#include "bssid_ignore.h" -#include "config.h" -#include "v1_1/iwpa_callback.h" -#include "v1_1/iwpa_interface.h" -#include "wpa_p2p_hal.h" - -#define HEX_TO_DEC_MOVING 4 -#define DEC_MAX_SCOPE 10 -#define MIN_MAC_LEN 6 - -struct HdiWpaKeyValue { - char key[CMD_SIZE]; - char value[CMD_SIZE]; -}; - -void GetStrKeyVal(char *src, const char *split, struct HdiWpaKeyValue *out) -{ - if (src == NULL || split == NULL || out == NULL) { - return; - } - char *p = strstr(src, split); - if (p == NULL) { - if (strcpy_s(out->key, sizeof(out->key), src) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - return; - } - *p = '\0'; - if (strcpy_s(out->key, sizeof(out->key), src) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - p += strlen(split); - if (strcpy_s(out->value, sizeof(out->value), p) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - return; -} - -void GetHalNetworkInfos(char *buf, struct HdiP2pNetworkInfo *info) -{ - if (buf == NULL || info == NULL) { - return; - } - int len = strlen(buf); - int start = 0; - int end = 0; - int i = 0; - const int count = 2; - while (end < len) { - if (buf[end] != '\t') { - ++end; - continue; - } - buf[end] = '\0'; - if (i == 0) { - info->id = atoi(buf); - } else if (i == 1) { - if (strcpy_s((char *)info->ssid, WIFI_SSID_LENGTH + 1, buf + start) != EOK) { - break; - } - printf_decode((u8 *)info->ssid, WIFI_SSID_LENGTH + 1, (char *)info->ssid); - } else if (i == count) { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(buf + start, tmpBssid); - if (strcpy_s((char *)info->bssid, ETH_ADDR_LEN + 1, (char *)tmpBssid) != EOK) { - break; - } - start = end + 1; - if (strcpy_s((char *)info->flags, WIFI_NETWORK_FLAGS_LENGTH + 1, buf + start) != EOK) { - break; - } - break; - } - ++i; - end++; - start = end; - } - return; -} - -int32_t WpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface *self, const char *ifName, const char *name) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || name == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetSsidPostfixName(pMainIfc, name); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface *self, const char *ifName, const char *type) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || type == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsDeviceType(pMainIfc, type); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface *self, const char *ifName, const char *methods) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || methods == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsConfigMethods(pMainIfc, methods); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface *self, const char *ifName, int32_t time) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); - if (pGroupIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pGroupIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetGroupIdle(pGroupIfc, time); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetWfdEnable(struct IWpaInterface *self, const char *ifName, int32_t enable) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdEnable(pMainIfc, enable); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface *self, const char *ifName, int32_t status) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetPersistentReconnect(pMainIfc, status); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface *self, const char *ifName, const char *type) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || type == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsSecDeviceType(pMainIfc, type); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetupWpsPbc(struct IWpaInterface *self, const char *ifName, const char *address) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || address == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); - if (pGroupIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pGroupIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPbc(pGroupIfc, address); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetupWpsPin(struct IWpaInterface *self, const char *ifName, const char *address, - const char *pin, char *result, uint32_t resultLen) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || address == NULL || pin == NULL || result == NULL || resultLen == 0) { - HDF_LOGE("%{public}s groupIfc, address, pin and result have NULL", __func__); - return HDF_FAILURE; - } - - P2pWpsPinDisplayArgv p2pWpsPinDisplay = {0}; - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); - if (pMainIfc == NULL || pGroupIfc == NULL) { - HDF_LOGE("%{public}s: pMainIfc or pGroupIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPin(pGroupIfc, &p2pWpsPinDisplay); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - HDF_LOGE("WpaP2pCliCmdWpsPin fail, ret = %{public}d", ret); - return HDF_FAILURE; - } - if (strlen(pin) > 0) { - p2pWpsPinDisplay.mode = P2P_PIN_KEYPAD; - if (strncpy_s(p2pWpsPinDisplay.pinCode, sizeof(p2pWpsPinDisplay.pinCode), pin, strlen(pin)) != EOK) { - HDF_LOGE("%{public}s: Failed to init pin code, the input pin code may be invalid!", __func__); - return HDF_FAILURE; - } - } else { - p2pWpsPinDisplay.mode = P2P_PIN_DISPLAY; - if ((strncpy_s(p2pWpsPinDisplay.bssid, sizeof(p2pWpsPinDisplay.bssid), address, strlen(address)) != EOK) || - (strncpy_s(result, resultLen, p2pWpsPinDisplay.pinCode, strlen(p2pWpsPinDisplay.pinCode)) != EOK)) { - HDF_LOGE("%{public}s: Failed to init request message, the input message may be invalid!", __func__); - return HDF_FAILURE; - } - } - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetPowerSave(struct IWpaInterface *self, const char *ifName, int32_t enable) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("P2pSetPowerSave, groupIfc is NULL"); - return HDF_FAILURE; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); - if (pGroupIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pGroupIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetPowerSave(pGroupIfc, enable); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetDeviceName(struct IWpaInterface *self, const char *ifName, const char *name) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || name == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsName(pMainIfc, name); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface *self, const char *ifName, const char *config) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || config == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdDeviceInfo(pMainIfc, config); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetRandomMac(struct IWpaInterface *self, const char *ifName, int32_t networkId) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetRandomMac(pMainIfc, networkId); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pStartFind(struct IWpaInterface *self, const char *ifName, int32_t timeout) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pFound(pMainIfc, timeout); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetExtListen(struct IWpaInterface *self, const char *ifName, int32_t enable, - int32_t period, int32_t interval) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdExtListen(pMainIfc, enable, period, interval); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetListenChannel(struct IWpaInterface *self, const char *ifName, - int32_t channel, int32_t regClass) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetListenChannel(pMainIfc, channel, regClass); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pProvisionDiscovery(struct IWpaInterface *self, const char *ifName, - const char *peerBssid, int32_t mode) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || peerBssid == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - P2pProvisionDiscoveryArgv p2pProvision; - if (memset_s(&p2pProvision, sizeof(p2pProvision), 0, sizeof(p2pProvision)) != EOK || - strncpy_s(p2pProvision.peerbssid, sizeof(p2pProvision.peerbssid), peerBssid, strlen(peerBssid)) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("Failed to init request message, the input message may be invalid!"); - return HDF_FAILURE; - } - p2pProvision.mode = mode; - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdProvisionDiscovery(pMainIfc, &p2pProvision); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pAddGroup(struct IWpaInterface *self, const char *ifName, int32_t isPersistent, - int32_t networkId, int32_t freq) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGroupAdd(pMainIfc, isPersistent, networkId, freq); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pAddService(struct IWpaInterface *self, const char *ifName, - const struct HdiP2pServiceInfo *info) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || info == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceAdd(pMainIfc, info); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pRemoveService(struct IWpaInterface *self, const char *ifName, - const struct HdiP2pServiceInfo *info) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || info == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceDel(pMainIfc, info); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pStopFind(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pStopFind(pMainIfc); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pFlush(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlush(pMainIfc); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pFlushService(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlushService(pMainIfc); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRemoveNetwork(pMainIfc, networkId); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId, - const char *name, const char *value) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - char cmd[CMD_SIZE] = {0}; - char buf[CMD_SIZE] = {0}; - int32_t ret = 0; - (void)self; - if (ifName == NULL || name == NULL || value == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET_NETWORK %d %s %s", - ifName, networkId, name, value); - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - return HDF_FAILURE; - } - if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s command failed!", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pInvite(struct IWpaInterface *self, const char *ifName, - const char *peerBssid, const char *goBssid) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (peerBssid == NULL || goBssid == NULL || ifName == NULL) { - HDF_LOGE("%{public}s: peerBssid, goBssid and ifname have NULL", __func__); - return HDF_FAILURE; - } - pthread_mutex_lock(GetInterfaceLock()); - P2pHalInviteArgv p2pHalInvite; - if (memset_s(&p2pHalInvite, sizeof(p2pHalInvite), 0, sizeof(p2pHalInvite)) != EOK || - strncpy_s(p2pHalInvite.peerbssid, sizeof(p2pHalInvite.peerbssid), peerBssid, strlen(peerBssid)) != EOK || - strncpy_s(p2pHalInvite.gobssid, sizeof(p2pHalInvite.gobssid), goBssid, strlen(goBssid)) != EOK || - strncpy_s(p2pHalInvite.ifname, sizeof(p2pHalInvite.ifname), ifName, strlen(ifName)) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("Failed to init request message, the input message may be invalid!"); - return HDF_FAILURE; - } - p2pHalInvite.persistent = 0; - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdInvite(pMainIfc, &p2pHalInvite); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pReinvoke(struct IWpaInterface *self, const char *ifName, const int32_t networkId, - const char *bssid) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || bssid == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - P2pHalReInviteArgv p2pHalReInvite; - if (memset_s(&p2pHalReInvite, sizeof(p2pHalReInvite), 0, sizeof(p2pHalReInvite)) != EOK || - strncpy_s(p2pHalReInvite.peerbssid, sizeof(p2pHalReInvite.peerbssid), bssid, strlen(bssid)) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("Failed to init request message, the input message may be invalid!"); - return HDF_FAILURE; - } - p2pHalReInvite.networkId = networkId; - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdReInvite(pMainIfc, &p2pHalReInvite); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pGetDeviceAddress(struct IWpaInterface *self, const char *ifName, char *deviceAddress, - uint32_t deviceAddressLen) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || deviceAddress == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - (void)self; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGetDeviceAddress(pMainIfc, deviceAddress, deviceAddressLen); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface *self, const char *ifName, - const struct HdiP2pReqService *reqService, char *replyDisc, uint32_t replyDiscLen) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || reqService == NULL || replyDisc == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - (void)self; - char seq[WIFI_P2P_SERVER_DISCOVERY_SEQUENCE_LENGTH] = {0}; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscReq(pMainIfc, (char *)reqService->bssid, - (char *)reqService->msg, seq, sizeof(seq)); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - if (strncpy_s(replyDisc, replyDiscLen, seq, strlen(seq)) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface *self, const char *ifName, const char *id) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || id == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscCancelReq(pMainIfc, id); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pRespServerDiscovery(struct IWpaInterface *self, const char *ifName, - const struct HdiP2pServDiscReqInfo *info) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || info == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - (void)self; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRespServerDiscovery(pMainIfc, info); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("WpaP2pCliCmdRespServerDiscovery fail, ret = %{public}d", ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, const struct HdiP2pConnectInfo *info, - char *replyPin, uint32_t replyPinLen) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || info == NULL || replyPin == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - char *reply; - const int replySize = REPLY_SIZE; - char cmd[CMD_SIZE] = {0}; - char join[CMD_SIZE] = {0}; - char mode[CMD_SIZE] = {0}; - char pin[CMD_SIZE] = {0}; - char peerDevAddr[CMD_SIZE] = {0}; - if (memcpy_s(pin, CMD_SIZE, info->pin, CMD_SIZE) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s strcpy failed", __func__); - return HDF_FAILURE; - } - - if (memcpy_s(peerDevAddr, CMD_SIZE, info->peerDevAddr, CMD_SIZE) != EOK) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s strcpy failed", __func__); - return HDF_FAILURE; - } - - reply = (char *)malloc(replySize); - if (reply == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is NULL!", __func__); - return HDF_FAILURE; - } - - int32_t ret = 0; - (void)self; - - if (info->mode != 0) { - if (strcpy_s(join, sizeof(join), " join") != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else { - if (snprintf_s(join, sizeof(join), sizeof(join) - 1, " go_intent=%d", info->goIntent) < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s input parameter invalid!", __func__); - free(reply); - return HDF_ERR_INVALID_PARAM; - } - } - - if (info->provdisc == P2P_WPS_METHOD_DISPLAY) { - if (strcpy_s(mode, sizeof(mode), " display") != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else if (info->provdisc == P2P_WPS_METHOD_KEYPAD) { - if (strcpy_s(mode, sizeof(mode), " keypad") != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else if (info->provdisc == P2P_WPS_METHOD_PBC && info->pin != NULL && strlen((char *)info->pin) == 0) { - if (strcpy_s(pin, CMD_SIZE, "pbc") != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s Mode value is invalid %{public}d!", __func__, info->provdisc); - free(reply); - return HDF_ERR_INVALID_PARAM; - } - - char persistent[CMD_SIZE] = {0}; - if (info->peerDevAddr && strlen(peerDevAddr) >= MIN_MAC_LEN) { - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_CONNECT %s %s%s%s%s", ifName, - macToStr(info->peerDevAddr), pin, mode, persistent, join); - } - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - free(reply); - return HDF_FAILURE; - } - - if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("P2P_CONNECT command failed!"); - free(reply); - return HDF_FAILURE; - } - - if (strncmp(reply, "FAIL", strlen("FAIL")) == 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s P2p connect return %{public}s", __func__, reply); - free(reply); - return HDF_FAILURE; - } - if (info->provdisc == P2P_WPS_METHOD_DISPLAY && strcmp((char *)info->pin, "pin") == 0) { - if (strncpy_s(replyPin, replyPinLen, reply, strlen(reply)) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s Failed to copy response pin code info!", __func__); - free(reply); - return HDF_FAILURE; - } - } - pthread_mutex_unlock(GetInterfaceLock()); - free(reply); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifName, - const struct HdiHid2dConnectInfo *info) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || info == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - char cmd[CMD_SIZE]; - char buf[CMD_SIZE]; - (void)self; - int freq = (info->frequency >> 16); - int isLegacyGo = (info->frequency & 0xffff); - if (freq < 0) { - HDF_LOGE("hid2dconnect freq is failed, freq=%{public}d", freq); - freq = 0; - } - HDF_LOGI("hid2dconnect freq=%{public}d, isLegacyGo=%{public}d", freq, isLegacyGo); - if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s MAGICLINK \"%s\"\n%s\n\"%s\"\n%d\n%d", ifName, - (char *)info->ssid, macToStr(info->bssid), (char *)info->passphrase, freq, isLegacyGo) < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s.", __func__, cmd); - return HDF_FAILURE; - } - if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("hid2d_connect command failed!"); - return HDF_FAILURE; - } - if (strncmp(buf, "FAIL", strlen("FAIL")) == 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: return %{public}s", __func__, buf); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSetServDiscExternal(struct IWpaInterface *self, const char *ifName, int32_t mode) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetServDiscExternal(pMainIfc, mode); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("WpaP2pCliCmdSetServDiscExternal fail, ret = %{public}d", ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pRemoveGroup(struct IWpaInterface *self, const char *ifName, const char *groupName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - if (ifName == NULL || groupName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pRemoveGroup(pMainIfc, groupName); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pCancelConnect(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdCancelConnect(pMainIfc); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pGetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId, - const char *param, char *value, uint32_t valueLen) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - char cmd[CMD_SIZE]; - - int32_t ret = 0; - (void)self; - if (ifName == NULL || param == NULL || value == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s GET_NETWORK %d %s", ifName, networkId, param); - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - return HDF_FAILURE; - } - if (WpaCliCmd(cmd, value, valueLen) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("GET_NETWORK command failed!"); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || networkId == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - (void)self; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdAddNetwork(pMainIfc, networkId); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("WpaP2pCliCmdAddNetwork fail, ret = %{public}d", ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} \ No newline at end of file diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test4.c b/wlan/wpa/interfaces/hdi_service/service_common/test4.c deleted file mode 100644 index 5262e2b3c3..0000000000 --- a/wlan/wpa/interfaces/hdi_service/service_common/test4.c +++ /dev/null @@ -1,1177 +0,0 @@ -int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, const char *bssid, - struct HdiP2pDeviceInfo *info) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || info == NULL || bssid == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - char *reply; - const int replySize = REPLY_SIZE; - char cmd[CMD_SIZE]; - - reply = (char *)malloc(replySize); - if (reply == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is NULL!", __func__); - return HDF_FAILURE; - } - - int32_t ret = 0; - (void)self; - - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - free(reply); - return HDF_FAILURE; - } - - if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("P2P_PEER command failed!"); - free(reply); - return HDF_FAILURE; - } - - if (strstr(reply, "\n") == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is error", __func__); - free(reply); - return HDF_FAILURE; - } - char *savedPtr = NULL; - char *token = strtok_r(reply, "\n", &savedPtr); - info->srcAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (info->srcAddress == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc srcAddress failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->p2pDeviceAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (info->p2pDeviceAddress == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc p2pDeviceAddress failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->primaryDeviceType = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_TYPE_LENGTH); - if (info->primaryDeviceType == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc primaryDeviceType failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->deviceName = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); - if (info->deviceName == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc deviceName failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->wfdDeviceInfo = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_WFD_DEVICE_INFO_LENGTH); - if (info->wfdDeviceInfo == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc wfdDeviceInfo failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->operSsid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); - if (info->operSsid == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc operSsid failed!"); - free(reply); - HdiP2pDeviceInfoFree(info, false); - return HDF_FAILURE; - } - info->srcAddressLen = ETH_ADDR_LEN + 1; - info->p2pDeviceAddressLen = ETH_ADDR_LEN + 1; - info->primaryDeviceTypeLen = WIFI_P2P_DEVICE_TYPE_LENGTH; - info->deviceNameLen = WIFI_P2P_DEVICE_NAME_LENGTH; - info->wfdDeviceInfoLen = WIFI_P2P_WFD_DEVICE_INFO_LENGTH; - info->operSsidLen = WIFI_P2P_DEVICE_NAME_LENGTH; - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(token, tmpBssid); - if (strcpy_s((char *)info->p2pDeviceAddress, ETH_ADDR_LEN + 1, (char *)tmpBssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - while (token != NULL) { - struct HdiWpaKeyValue retMsg = {{0}, {0}}; - GetStrKeyVal(token, "=", &retMsg); - if (strncmp(retMsg.key, "pri_dev_type", strlen("pri_dev_type")) == 0) { - if (strcpy_s((char *)info->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH + 1, retMsg.value) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else if (strncmp(retMsg.key, "device_name", strlen("device_name")) == 0) { - if (strcpy_s((char *)info->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } else if (strncmp(retMsg.key, "config_methods", strlen("config_methods")) == 0) { - info->configMethods = Hex2Dec(retMsg.value); - } else if (strncmp(retMsg.key, "dev_capab", strlen("dev_capab")) == 0) { - info->deviceCapabilities = Hex2Dec(retMsg.value); - } else if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) { - info->groupCapabilities = Hex2Dec(retMsg.value); - } else if (strncmp(retMsg.key, "oper_ssid", strlen("oper_ssid")) == 0) { - if (strcpy_s((char *)info->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - token = strtok_r(NULL, "\n", &savedPtr); - } - pthread_mutex_unlock(GetInterfaceLock()); - free(reply); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char *ifName, - const char *bssid, int32_t *cap) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || bssid == NULL || cap == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - char *reply; - const int replySize = REPLY_SIZE; - char cmd[CMD_SIZE]; - - reply = (char *)malloc(replySize); - if (reply == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is NULL!", __func__); - return HDF_FAILURE; - } - - int32_t ret = 0; - (void)self; - - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - free(reply); - return HDF_FAILURE; - } - - if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("P2P_PEER command failed!"); - free(reply); - return HDF_FAILURE; - } - - if (strstr(reply, "\n") == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is error", __func__); - free(reply); - return HDF_FAILURE; - } - char *savedPtr = NULL; - char *token = strtok_r(reply, "\n", &savedPtr); - - while (token != NULL) { - struct HdiWpaKeyValue retMsg = {{0}, {0}}; - GetStrKeyVal(token, "=", &retMsg); - if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) { - *cap = Hex2Dec(retMsg.value); - } - token = strtok_r(NULL, "\n", &savedPtr); - } - pthread_mutex_unlock(GetInterfaceLock()); - free(reply); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifName, - struct HdiP2pNetworkList *infoList) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - if (ifName == NULL || infoList == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - char *reply; - const int replySize = REPLY_SIZE; - char cmd[CMD_SIZE]; - reply = (char *)malloc(replySize); - if (reply == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is NULL!", __func__); - return HDF_FAILURE; - } - - (void)self; - if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s LIST_NETWORKS", ifName) < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("snprintf err"); - free(reply); - return HDF_FAILURE; - } - if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("LIST_NETWORKS command failed!"); - free(reply); - return HDF_FAILURE; - } - - char *token = strstr(reply, "\n"); - if (token == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s token is NULL!", __func__); - free(reply); - return HDF_FAILURE; - } - char *tmpPos = token + 1; - while ((tmpPos = strstr(tmpPos, "\n")) != NULL) { - infoList->infoNum += 1; - ++tmpPos; - } - if (infoList->infoNum <= 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s infoList->infoNum <= 0", __func__); - free(reply); - return HDF_FAILURE; - } - infoList->infos = (struct HdiP2pNetworkInfo *)OsalMemCalloc(sizeof(struct HdiP2pNetworkInfo) * infoList->infoNum); - if (infoList->infos == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("malloc infos failed!"); - free(reply); - return HDF_FAILURE; - } - infoList->infosLen = (uint32_t)infoList->infoNum; - char *tmpBuf = token + 1; - char *savedPtr = NULL; - token = strtok_r(tmpBuf, "\n", &savedPtr); - int index = 0; - while (token != NULL) { - if (index >= infoList->infoNum) { - break; - } - infoList->infos[index].ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_SSID_LENGTH); - if (infoList->infos[index].ssid == NULL) { - HDF_LOGE("malloc ssid failed!"); - HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); - break; - } - infoList->infos[index].ssidLen = WIFI_SSID_LENGTH; - infoList->infos[index].bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (infoList->infos[index].bssid == NULL) { - HDF_LOGE("malloc bssid failed!"); - HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); - break; - } - infoList->infos[index].bssidLen = ETH_ADDR_LEN + 1; - infoList->infos[index].flags = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_NETWORK_FLAGS_LENGTH); - if (infoList->infos[index].flags == NULL) { - HDF_LOGE("malloc flags failed!"); - HdiP2pNetworkInfoFree(&(infoList->infos[index]), true); - break; - } - infoList->infos[index].flagsLen = WIFI_NETWORK_FLAGS_LENGTH; - GetHalNetworkInfos(token, &(infoList->infos[index])); - index++; - token = strtok_r(NULL, "\n", &savedPtr); - } - pthread_mutex_unlock(GetInterfaceLock()); - free(reply); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceP2pSaveConfig(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - pthread_mutex_lock(GetInterfaceLock()); - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdStoreConfig(pMainIfc); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDeliverP2pData(struct IWpaInterface *self, const char *ifName, - int32_t cmdType, int32_t dataType, const char *carryData) -{ - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - (void)self; - (void)ifName; - char cmd[CMD_SIZE] = {0}; - char buf[CMD_SIZE] = {0}; - - int32_t ret = 0; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(GetInterfaceLock()); - ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, - "IFNAME=%s P2P_DELIVER_DATA cmdType=%d dataType=%d carryData=%s", ifName, cmdType, dataType, carryData); - if (ret < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); - return HDF_FAILURE; - } - if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s command failed!", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s success", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceVendorExtProcessCmd(struct IWpaInterface *self, const char *ifName, const char *cmd) -{ -#define NEW_CMD_MAX_LEN 400 - HDF_LOGI("Ready to enter hdi %{public}s", __func__); - int32_t ret = 0; - (void)self; - if (cmd == NULL || ifName == NULL) { - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - pthread_mutex_lock(GetInterfaceLock()); - char *reply; - const int replySize = REPLY_SIZE; - reply = (char *)malloc(replySize); - if (reply == NULL) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s reply is NULL!", __func__); - return HDF_FAILURE; - } - - char newCmd[NEW_CMD_MAX_LEN] = {0}; - if (snprintf_s(newCmd, sizeof(newCmd), sizeof(newCmd) - 1, "IFNAME=%s %s", ifName, cmd) < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s: snprintf_s is failed, error code: %{public}d", __func__, ret); - free(reply); - return HDF_FAILURE; - } - - if (WpaCliCmd(newCmd, reply, replySize) < 0) { - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGE("%{public}s WpaCliCmd failed!", __func__); - free(reply); - return HDF_FAILURE; - } -<<<<<<< HEAD - - HDF_LOGI("%{public}s reply %{public}s !", __func__, reply); -======= - pthread_mutex_unlock(GetInterfaceLock()); - HDF_LOGI("%{public}s cmd %{public}s reply %{public}s !", __func__, newCmd, reply); ->>>>>>> da9bf65ec (TicketNo:DTS2024081411562) - ret = atoi(reply); - free(reply); - return ret; -} - -static int32_t WpaFillP2pDeviceFoundParam(struct P2pDeviceInfoParam *deviceInfoParam, - struct HdiP2pDeviceInfoParam *hdiP2pDeviceInfoParam) -{ - int32_t ret = 0; - if (deviceInfoParam == NULL || hdiP2pDeviceInfoParam == NULL) { - HDF_LOGE("%{public}s: deviceInfoParam or hdiP2pDeviceInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pDeviceInfoParam->configMethods = deviceInfoParam->configMethods; - hdiP2pDeviceInfoParam->deviceCapabilities = deviceInfoParam->deviceCapabilities; - hdiP2pDeviceInfoParam->groupCapabilities = deviceInfoParam->groupCapabilities; - hdiP2pDeviceInfoParam->wfdLength = deviceInfoParam->wfdLength; - - do { - if (FillData(&hdiP2pDeviceInfoParam->srcAddress, &hdiP2pDeviceInfoParam->srcAddressLen, - deviceInfoParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pDeviceInfoParam->p2pDeviceAddress, &hdiP2pDeviceInfoParam->p2pDeviceAddressLen, - deviceInfoParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pDeviceInfoParam->primaryDeviceType, &hdiP2pDeviceInfoParam->primaryDeviceTypeLen, - deviceInfoParam->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pDeviceInfoParam->deviceName, &hdiP2pDeviceInfoParam->deviceNameLen, - deviceInfoParam->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (deviceInfoParam->wfdLength != 0 && - FillData(&hdiP2pDeviceInfoParam->wfdDeviceInfo, &hdiP2pDeviceInfoParam->wfdDeviceInfoLen, - deviceInfoParam->wfdDeviceInfo, deviceInfoParam->wfdLength) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pDeviceInfoParam->operSsid, &hdiP2pDeviceInfoParam->operSsidLen, - deviceInfoParam->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill reason fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pDeviceInfoParam->srcAddress != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->srcAddress); - hdiP2pDeviceInfoParam->srcAddress = NULL; - } - if (hdiP2pDeviceInfoParam->p2pDeviceAddress != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->p2pDeviceAddress); - hdiP2pDeviceInfoParam->p2pDeviceAddress = NULL; - } - if (hdiP2pDeviceInfoParam->primaryDeviceType != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->primaryDeviceType); - hdiP2pDeviceInfoParam->primaryDeviceType = NULL; - } - if (hdiP2pDeviceInfoParam->deviceName != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->deviceName); - hdiP2pDeviceInfoParam->deviceName = NULL; - } - if (hdiP2pDeviceInfoParam->wfdDeviceInfo != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->wfdDeviceInfo); - hdiP2pDeviceInfoParam->wfdDeviceInfo = NULL; - } - if (hdiP2pDeviceInfoParam->operSsid != NULL) { - OsalMemFree(hdiP2pDeviceInfoParam->operSsid); - hdiP2pDeviceInfoParam->operSsid = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pDeviceLostParam(struct P2pDeviceLostParam *deviceLostParam, - struct HdiP2pDeviceLostParam *hdiP2pDeviceLostParam) -{ - int32_t ret = 0; - if (deviceLostParam == NULL || hdiP2pDeviceLostParam == NULL) { - HDF_LOGE("%{public}s: deviceLostParam or hdiP2pDeviceLostParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pDeviceLostParam->networkId = deviceLostParam->networkId; - - if (FillData(&hdiP2pDeviceLostParam->p2pDeviceAddress, &hdiP2pDeviceLostParam->p2pDeviceAddressLen, - deviceLostParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiP2pDeviceLostParam->p2pDeviceAddress != NULL) { - OsalMemFree(hdiP2pDeviceLostParam->p2pDeviceAddress); - hdiP2pDeviceLostParam->p2pDeviceAddress = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pGoNegotiationRequestParam(struct P2pGoNegotiationRequestParam *goNegotiationRequestParam, - struct HdiP2pGoNegotiationRequestParam *hdiP2pGoNegotiationRequestParam) -{ - int32_t ret = 0; - if (goNegotiationRequestParam == NULL || hdiP2pGoNegotiationRequestParam == NULL) { - HDF_LOGE("%{public}s: goNegotiationRequestParam or hdiP2pGoNegotiationRequestParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pGoNegotiationRequestParam->passwordId = goNegotiationRequestParam->passwordId; - - if (FillData(&hdiP2pGoNegotiationRequestParam->srcAddress, &hdiP2pGoNegotiationRequestParam->srcAddressLen, - goNegotiationRequestParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiP2pGoNegotiationRequestParam->srcAddress != NULL) { - OsalMemFree(hdiP2pGoNegotiationRequestParam->srcAddress); - hdiP2pGoNegotiationRequestParam->srcAddress = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pGoNegotiationCompletedParam(struct P2pGoNegotiationCompletedParam - *goNegotiationCompletedParam, struct HdiP2pGoNegotiationCompletedParam *hdiP2pGoNegotiationCompletedParam) -{ - int32_t ret = 0; - if (goNegotiationCompletedParam == NULL || hdiP2pGoNegotiationCompletedParam == NULL) { - HDF_LOGE("%{public}s: goNegotiationCompletedParam or hdiP2pGoNegotiationCompletedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pGoNegotiationCompletedParam->status = goNegotiationCompletedParam->status; - return ret; -} - -static int32_t WpaFillP2pInvitationReceivedParam(struct P2pInvitationReceivedParam *invitationReceivedParam, - struct HdiP2pInvitationReceivedParam *hdiP2pInvitationReceivedParam) -{ - int32_t ret = HDF_SUCCESS; - if (invitationReceivedParam == NULL || hdiP2pInvitationReceivedParam == NULL) { - HDF_LOGE("%{public}s: invitationReceivedParam or hdiP2pInvitationReceivedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pInvitationReceivedParam->type = invitationReceivedParam->type; - hdiP2pInvitationReceivedParam->persistentNetworkId = invitationReceivedParam->persistentNetworkId; - hdiP2pInvitationReceivedParam->operatingFrequency = invitationReceivedParam->operatingFrequency; - - do { - if (FillData(&hdiP2pInvitationReceivedParam->srcAddress, &hdiP2pInvitationReceivedParam->srcAddressLen, - invitationReceivedParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pInvitationReceivedParam->goDeviceAddress, - &hdiP2pInvitationReceivedParam->goDeviceAddressLen, - invitationReceivedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pInvitationReceivedParam->bssid, &hdiP2pInvitationReceivedParam->bssidLen, - invitationReceivedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pInvitationReceivedParam->srcAddress != NULL) { - OsalMemFree(hdiP2pInvitationReceivedParam->srcAddress); - hdiP2pInvitationReceivedParam->srcAddress = NULL; - } - if (hdiP2pInvitationReceivedParam->goDeviceAddress != NULL) { - OsalMemFree(hdiP2pInvitationReceivedParam->goDeviceAddress); - hdiP2pInvitationReceivedParam->goDeviceAddress = NULL; - } - if (hdiP2pInvitationReceivedParam->bssid != NULL) { - OsalMemFree(hdiP2pInvitationReceivedParam->bssid); - hdiP2pInvitationReceivedParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pInvitationResultParam(struct P2pInvitationResultParam *invitationResultParam, - struct HdiP2pInvitationResultParam *hdiP2pInvitationResultParam) -{ - int32_t ret = HDF_SUCCESS; - if (invitationResultParam == NULL || hdiP2pInvitationResultParam == NULL) { - HDF_LOGE("%{public}s: invitationResultParam or hdiP2pInvitationResultParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pInvitationResultParam->status = invitationResultParam->status; - - if (FillData(&hdiP2pInvitationResultParam->bssid, &hdiP2pInvitationResultParam->bssidLen, - invitationResultParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiP2pInvitationResultParam->bssid != NULL) { - OsalMemFree(hdiP2pInvitationResultParam->bssid); - hdiP2pInvitationResultParam->bssid = NULL; - } - } - return ret; -} - -static int32_t FillHdiP2pGroupInfoStartedParam(struct P2pGroupStartedParam *groupStartedParam, - struct HdiP2pGroupInfoStartedParam *hdiP2pGroupStartedParam) -{ - int32_t ret = HDF_SUCCESS; - if (groupStartedParam == NULL || hdiP2pGroupStartedParam == NULL) { - HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupStartedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - if (FillData(&hdiP2pGroupStartedParam->groupIfName, &hdiP2pGroupStartedParam->groupIfNameLen, - groupStartedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill groupIfName fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pGroupStartedParam->ssid, &hdiP2pGroupStartedParam->ssidLen, - groupStartedParam->ssid, WIFI_SSID_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pGroupStartedParam->psk, &hdiP2pGroupStartedParam->pskLen, - groupStartedParam->psk, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill psk fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pGroupStartedParam->passphrase, &hdiP2pGroupStartedParam->passphraseLen, - groupStartedParam->passphrase, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill passphrase fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pGroupStartedParam->goDeviceAddress, &hdiP2pGroupStartedParam->goDeviceAddressLen, - groupStartedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill goDeviceAddress fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiP2pGroupStartedParam->goRandomDeviceAddress, - &hdiP2pGroupStartedParam->goRandomDeviceAddressLen, - groupStartedParam->goRandomDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill goRandomDeviceAddress fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - return ret; -} - -static int32_t WpaFillP2pGroupInfoStartedParam(struct P2pGroupStartedParam *groupStartedParam, - struct HdiP2pGroupInfoStartedParam *hdiP2pGroupStartedParam) -{ - int32_t ret = HDF_SUCCESS; - if (groupStartedParam == NULL || hdiP2pGroupStartedParam == NULL) { - HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupStartedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pGroupStartedParam->isGo = groupStartedParam->isGo; - hdiP2pGroupStartedParam->isPersistent = groupStartedParam->isPersistent; - hdiP2pGroupStartedParam->frequency = groupStartedParam->frequency; - ret = FillHdiP2pGroupInfoStartedParam(groupStartedParam, hdiP2pGroupStartedParam); - if (ret != HDF_SUCCESS) { - if (hdiP2pGroupStartedParam->groupIfName != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->groupIfName); - hdiP2pGroupStartedParam->groupIfName = NULL; - } - if (hdiP2pGroupStartedParam->ssid != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->ssid); - hdiP2pGroupStartedParam->ssid = NULL; - } - if (hdiP2pGroupStartedParam->psk != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->psk); - hdiP2pGroupStartedParam->psk = NULL; - } - if (hdiP2pGroupStartedParam->passphrase != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->passphrase); - hdiP2pGroupStartedParam->passphrase = NULL; - } - if (hdiP2pGroupStartedParam->goDeviceAddress != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->goDeviceAddress); - hdiP2pGroupStartedParam->goDeviceAddress = NULL; - } - if (hdiP2pGroupStartedParam->goRandomDeviceAddress != NULL) { - OsalMemFree(hdiP2pGroupStartedParam->goRandomDeviceAddress); - hdiP2pGroupStartedParam->goRandomDeviceAddress = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pGroupRemovedParam(struct P2pGroupRemovedParam *groupRemovedParam, - struct HdiP2pGroupRemovedParam *hdiP2pGroupRemovedParam) -{ - int32_t ret = HDF_SUCCESS; - if (groupRemovedParam == NULL || hdiP2pGroupRemovedParam == NULL) { - HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupRemovedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pGroupRemovedParam->isGo = groupRemovedParam->isGo; - - if (FillData(&hdiP2pGroupRemovedParam->groupIfName, &hdiP2pGroupRemovedParam->groupIfNameLen, - groupRemovedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiP2pGroupRemovedParam->groupIfName != NULL) { - OsalMemFree(hdiP2pGroupRemovedParam->groupIfName); - hdiP2pGroupRemovedParam->groupIfName = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pProvisionDiscoveryCompletedParam(struct P2pProvisionDiscoveryCompletedParam - *provisionDiscoveryCompletedParam, - struct HdiP2pProvisionDiscoveryCompletedParam *hdiP2pProvisionDiscoveryCompletedParam) -{ - int32_t ret = HDF_SUCCESS; - if (provisionDiscoveryCompletedParam == NULL || hdiP2pProvisionDiscoveryCompletedParam == NULL) { - HDF_LOGE("%{public}s: provisionDiscoveryCompletedParam or hdiP2pProvisionDiscoveryCompletedParam is NULL!", - __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pProvisionDiscoveryCompletedParam->isRequest = provisionDiscoveryCompletedParam->isRequest; - hdiP2pProvisionDiscoveryCompletedParam->provDiscStatusCode = provisionDiscoveryCompletedParam->provDiscStatusCode; - hdiP2pProvisionDiscoveryCompletedParam->configMethods = provisionDiscoveryCompletedParam->configMethods; - - do { - if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress, - &hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddressLen, - provisionDiscoveryCompletedParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->generatedPin, - &hdiP2pProvisionDiscoveryCompletedParam->generatedPinLen, - provisionDiscoveryCompletedParam->generatedPin, WIFI_PIN_CODE_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress != NULL) { - OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress); - hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress = NULL; - } - if (hdiP2pProvisionDiscoveryCompletedParam->generatedPin != NULL) { - OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->generatedPin); - hdiP2pProvisionDiscoveryCompletedParam->generatedPin = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pServDiscReqParam(struct P2pServDiscReqInfoParam *servDiscReqInfo, - struct HdiP2pServDiscReqInfoParam *hdiP2pServDiscReqInfo) -{ - int32_t ret = HDF_SUCCESS; - if (servDiscReqInfo == NULL || hdiP2pServDiscReqInfo == NULL) { - HDF_LOGE("%{public}s: servDiscReqInfo or hdiP2pServDiscReqInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pServDiscReqInfo->freq = servDiscReqInfo->freq; - hdiP2pServDiscReqInfo->dialogToken = servDiscReqInfo->dialogToken; - hdiP2pServDiscReqInfo->updateIndic = servDiscReqInfo->updateIndic; - - do { - if (FillData(&hdiP2pServDiscReqInfo->mac, &hdiP2pServDiscReqInfo->macLen, - servDiscReqInfo->mac, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pServDiscReqInfo->tlvs, &hdiP2pServDiscReqInfo->tlvsLen, - servDiscReqInfo->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pServDiscReqInfo->mac != NULL) { - OsalMemFree(hdiP2pServDiscReqInfo->mac); - hdiP2pServDiscReqInfo->mac = NULL; - } - if (hdiP2pServDiscReqInfo->tlvs != NULL) { - OsalMemFree(hdiP2pServDiscReqInfo->tlvs); - hdiP2pServDiscReqInfo->tlvs = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pServDiscRespParam(struct P2pServDiscRespParam *servDiscRespParam, - struct HdiP2pServDiscRespParam *hdiP2pServDiscRespParam) -{ - int32_t ret = HDF_SUCCESS; - if (servDiscRespParam == NULL || hdiP2pServDiscRespParam == NULL) { - HDF_LOGE("%{public}s: servDiscRespParam or hdiP2pServDiscRespParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pServDiscRespParam->updateIndicator = servDiscRespParam->updateIndicator; - - do { - if (FillData(&hdiP2pServDiscRespParam->srcAddress, &hdiP2pServDiscRespParam->srcAddressLen, - servDiscRespParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pServDiscRespParam->tlvs, &hdiP2pServDiscRespParam->tlvsLen, - servDiscRespParam->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pServDiscRespParam->srcAddress != NULL) { - OsalMemFree(hdiP2pServDiscRespParam->srcAddress); - hdiP2pServDiscRespParam->srcAddress = NULL; - } - if (hdiP2pServDiscRespParam->tlvs != NULL) { - OsalMemFree(hdiP2pServDiscRespParam->tlvs); - hdiP2pServDiscRespParam->tlvs = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pStaConnectStateParam(struct P2pStaConnectStateParam *staConnectStateParam, - struct HdiP2pStaConnectStateParam *hdiP2pStaConnectStateParam) -{ - int32_t ret = HDF_SUCCESS; - if (staConnectStateParam == NULL || hdiP2pStaConnectStateParam == NULL) { - HDF_LOGE("%{public}s: staConnectStateParam or hdiP2pStaConnectStateParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pStaConnectStateParam->state = staConnectStateParam->state; - do { - if (FillData(&hdiP2pStaConnectStateParam->srcAddress, &hdiP2pStaConnectStateParam->srcAddressLen, - staConnectStateParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiP2pStaConnectStateParam->p2pDeviceAddress, &hdiP2pStaConnectStateParam->p2pDeviceAddressLen, - staConnectStateParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - - if (ret != HDF_SUCCESS) { - if (hdiP2pStaConnectStateParam->srcAddress != NULL) { - OsalMemFree(hdiP2pStaConnectStateParam->srcAddress); - hdiP2pStaConnectStateParam->srcAddress = NULL; - } - if (hdiP2pStaConnectStateParam->p2pDeviceAddress != NULL) { - OsalMemFree(hdiP2pStaConnectStateParam->p2pDeviceAddress); - hdiP2pStaConnectStateParam->p2pDeviceAddress = NULL; - } - } - return ret; -} - -static int32_t WpaFillP2pIfaceCreatedParam(struct P2pIfaceCreatedParam *ifaceCreatedParam, - struct HdiP2pIfaceCreatedParam *hdiP2pIfaceCreatedParam) -{ - int32_t ret = HDF_SUCCESS; - if (ifaceCreatedParam == NULL || hdiP2pIfaceCreatedParam == NULL) { - HDF_LOGE("%{public}s: ifaceCreatedParam or hdiP2pIfaceCreatedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiP2pIfaceCreatedParam->isGo = ifaceCreatedParam->isGo; - return ret; -} - -int32_t ProcessEventP2pDeviceFound(struct HdfWpaRemoteNode *node, - struct P2pDeviceInfoParam *deviceInfoParam, const char *ifName) -{ - struct HdiP2pDeviceInfoParam hdiP2pDeviceInfo = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceFound == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pDeviceFoundParam(deviceInfoParam, &hdiP2pDeviceInfo) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pDeviceInfo is NULL or deviceInfoParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventDeviceFound(node->callbackObj, &hdiP2pDeviceInfo, ifName); - } - HdiP2pDeviceInfoParamFree(&hdiP2pDeviceInfo, false); - return ret; -} - -int32_t ProcessEventP2pDeviceLost(struct HdfWpaRemoteNode *node, - struct P2pDeviceLostParam *deviceLostParam, const char *ifName) -{ - struct HdiP2pDeviceLostParam hdiP2pDeviceLostParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceLost == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pDeviceLostParam(deviceLostParam, &hdiP2pDeviceLostParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pDeviceLostParam is NULL or deviceLostParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventDeviceLost(node->callbackObj, &hdiP2pDeviceLostParam, ifName); - } - HdiP2pDeviceLostParamFree(&hdiP2pDeviceLostParam, false); - return ret; -} - -int32_t ProcessEventP2pGoNegotiationRequest(struct HdfWpaRemoteNode *node, - struct P2pGoNegotiationRequestParam *goNegotiationRequestParam, const char *ifName) -{ - struct HdiP2pGoNegotiationRequestParam hdiP2pGoNegotiationRequestParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationRequest == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pGoNegotiationRequestParam(goNegotiationRequestParam, - &hdiP2pGoNegotiationRequestParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pGoNegotiationRequestParam is NULL or goNegotiationRequestParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventGoNegotiationRequest(node->callbackObj, - &hdiP2pGoNegotiationRequestParam, ifName); - } - HdiP2pGoNegotiationRequestParamFree(&hdiP2pGoNegotiationRequestParam, false); - return ret; -} - -int32_t ProcessEventP2pGoNegotiationCompleted(struct HdfWpaRemoteNode *node, struct P2pGoNegotiationCompletedParam - *goNegotiationCompletedParam, const char *ifName) -{ - struct HdiP2pGoNegotiationCompletedParam hdiP2pGoNegotiationCompletedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationCompleted == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pGoNegotiationCompletedParam(goNegotiationCompletedParam, - &hdiP2pGoNegotiationCompletedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pGoNegotiationCompletedParam is NULL or goNegotiationCompletedParam fialed!", - __func__); - } else { - ret = node->callbackObj->OnEventGoNegotiationCompleted(node->callbackObj, - &hdiP2pGoNegotiationCompletedParam, ifName); - } - HdiP2pGoNegotiationCompletedParamFree(&hdiP2pGoNegotiationCompletedParam, false); - return ret; -} - -int32_t ProcessEventP2pInvitationReceived(struct HdfWpaRemoteNode *node, - struct P2pInvitationReceivedParam *invitationReceivedParam, const char *ifName) -{ - struct HdiP2pInvitationReceivedParam hdiP2pInvitationReceivedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationReceived == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pInvitationReceivedParam(invitationReceivedParam, &hdiP2pInvitationReceivedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pInvitationReceivedParam is NULL or invitationReceivedParam fialed!", __func__); - return ret; - } else { - ret = node->callbackObj->OnEventInvitationReceived(node->callbackObj, &hdiP2pInvitationReceivedParam, ifName); - } - HdiP2pInvitationReceivedParamFree(&hdiP2pInvitationReceivedParam, false); - return ret; -} - -int32_t ProcessEventP2pInvitationResult(struct HdfWpaRemoteNode *node, - struct P2pInvitationResultParam *invitationResultParam, const char *ifName) -{ - struct HdiP2pInvitationResultParam hdiP2pInvitationResultParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationResult == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pInvitationResultParam(invitationResultParam, &hdiP2pInvitationResultParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pInvitationResultParam is NULL or invitationResultParam fialed!", __func__); - return ret; - } else { - ret = node->callbackObj->OnEventInvitationResult(node->callbackObj, &hdiP2pInvitationResultParam, ifName); - } - HdiP2pInvitationResultParamFree(&hdiP2pInvitationResultParam, false); - return ret; -} - -int32_t ProcessEventP2pGroupFormationSuccess(struct HdfWpaRemoteNode *node, - const char *ifName) -{ - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - ret = node->callbackObj->OnEventGroupFormationSuccess(node->callbackObj, ifName); - return ret; -} - -int32_t ProcessEventP2pGroupFormationFailure(struct HdfWpaRemoteNode *node, char *reason, - const char *ifName) -{ - char *hdiReason = NULL; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupFormationFailure == NULL || - reason == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiReason = (char *)OsalMemCalloc(WIFI_REASON_LENGTH); - if ((hdiReason == NULL) || (strncpy_s(hdiReason, WIFI_REASON_LENGTH, reason, strlen(reason)) != HDF_SUCCESS)) { - HDF_LOGE("%{public}s: hdiReason is NULL or reason fialed!", __func__); - } else { - ret = node->callbackObj->OnEventGroupFormationFailure(node->callbackObj, hdiReason, ifName); - } - OsalMemFree(hdiReason); - hdiReason = NULL; - return ret; -} - -int32_t ProcessEventP2pGroupStarted(struct HdfWpaRemoteNode *node, - struct P2pGroupStartedParam *groupStartedParam, const char *ifName) -{ - struct HdiP2pGroupInfoStartedParam hdiP2pGroupInfoStartedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupInfoStarted == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pGroupInfoStartedParam(groupStartedParam, &hdiP2pGroupInfoStartedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pGroupStartedParam is NULL or groupStartedParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventGroupInfoStarted(node->callbackObj, &hdiP2pGroupInfoStartedParam, ifName); - } - HdiP2pGroupInfoStartedParamFree(&hdiP2pGroupInfoStartedParam, false); - return ret; -} - -int32_t ProcessEventP2pGroupRemoved(struct HdfWpaRemoteNode *node, - struct P2pGroupRemovedParam *groupRemovedParam, const char *ifName) -{ - struct HdiP2pGroupRemovedParam hdiP2pGroupRemovedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupRemoved == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pGroupRemovedParam(groupRemovedParam, &hdiP2pGroupRemovedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pGroupRemovedParam is NULL or groupRemovedParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventGroupRemoved(node->callbackObj, &hdiP2pGroupRemovedParam, ifName); - } - HdiP2pGroupRemovedParamFree(&hdiP2pGroupRemovedParam, false); - return ret; -} - -int32_t ProcessEventP2pProvisionDiscoveryCompleted(struct HdfWpaRemoteNode *node, - struct P2pProvisionDiscoveryCompletedParam *provisionDiscoveryCompletedParam, const char *ifName) -{ - struct HdiP2pProvisionDiscoveryCompletedParam hdiP2pProvisionDiscoveryCompletedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventProvisionDiscoveryCompleted == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pProvisionDiscoveryCompletedParam(provisionDiscoveryCompletedParam, - &hdiP2pProvisionDiscoveryCompletedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Param is NULL or provisionDiscoveryCompletedParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventProvisionDiscoveryCompleted(node->callbackObj, - &hdiP2pProvisionDiscoveryCompletedParam, ifName); - } - HdiP2pProvisionDiscoveryCompletedParamFree(&hdiP2pProvisionDiscoveryCompletedParam, false); - return ret; -} - -int32_t ProcessEventP2pFindStopped(struct HdfWpaRemoteNode *node, - const char *ifName) -{ - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - ret = node->callbackObj->OnEventFindStopped(node->callbackObj, ifName); - return ret; -} - -int32_t ProcessEventP2pServDiscReq(struct HdfWpaRemoteNode *node, - struct P2pServDiscReqInfoParam *servDiscReqInfo, const char *ifName) -{ - struct HdiP2pServDiscReqInfoParam hdiP2pServDiscReqInfo = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscReq == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pServDiscReqParam(servDiscReqInfo, &hdiP2pServDiscReqInfo) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pServDiscReqInfo is NULL or servDiscReqInfo fialed!", __func__); - } else { - ret = node->callbackObj->OnEventServDiscReq(node->callbackObj, &hdiP2pServDiscReqInfo, ifName); - } - HdiP2pServDiscReqInfoParamFree(&hdiP2pServDiscReqInfo, false); - return ret; -} - -int32_t ProcessEventP2pServDiscResp(struct HdfWpaRemoteNode *node, - struct P2pServDiscRespParam *servDiscRespParam, const char *ifName) -{ - struct HdiP2pServDiscRespParam hdiP2pServDiscRespParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscResp == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pServDiscRespParam(servDiscRespParam, &hdiP2pServDiscRespParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pServDiscRespParam is NULL or servDiscRespParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventServDiscResp(node->callbackObj, &hdiP2pServDiscRespParam, ifName); - } - HdiP2pServDiscRespParamFree(&hdiP2pServDiscRespParam, false); - return ret; -} - -int32_t ProcessEventP2pStaConnectState(struct HdfWpaRemoteNode *node, - struct P2pStaConnectStateParam *staConnectStateParam, const char *ifName) -{ - struct HdiP2pStaConnectStateParam hdiP2pStaConnectStateParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaConnectState == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pStaConnectStateParam(staConnectStateParam, &hdiP2pStaConnectStateParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pStaConnectStateParam is NULL or staConnectStateParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventStaConnectState(node->callbackObj, &hdiP2pStaConnectStateParam, ifName); - } - HdiP2pStaConnectStateParamFree(&hdiP2pStaConnectStateParam, false); - return ret; -} - -int32_t ProcessEventP2pIfaceCreated(struct HdfWpaRemoteNode *node, struct P2pIfaceCreatedParam *ifaceCreatedParam, - const char *ifName) -{ - struct HdiP2pIfaceCreatedParam hdiP2pIfaceCreatedParam = {0}; - int32_t ret = HDF_FAILURE; - if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventIfaceCreated == NULL) { - HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (WpaFillP2pIfaceCreatedParam(ifaceCreatedParam, &hdiP2pIfaceCreatedParam) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: hdiP2pIfaceCreatedParam is NULL or ifaceCreatedParam fialed!", __func__); - } else { - ret = node->callbackObj->OnEventIfaceCreated(node->callbackObj, &hdiP2pIfaceCreatedParam, ifName); - } - HdiP2pIfaceCreatedParamFree(&hdiP2pIfaceCreatedParam, false); - return ret; -} diff --git a/wlan/wpa/interfaces/hdi_service/service_common/test5.c b/wlan/wpa/interfaces/hdi_service/service_common/test5.c deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index c3abccb9f7..5736767755 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -40,11 +40,11 @@ #define BUF_SIZE 512 - pthread_t g_tid; const int QUOTATION_MARKS_FLAG_YES = 0; const int QUOTATION_MARKS_FLAG_NO = 1; const int MAX_NETWORKS_NUM = 100; +pthread_mutex_t g_interfaceLock = PTHREAD_MUTEX_INITIALIZER; static WpaSsidField g_wpaSsidFields[] = { {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES}, @@ -100,6 +100,11 @@ int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_L return flag; } +pthread_mutex_t *GetInterfaceLock() +{ + return &g_interfaceLock; +} + int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) { if (src == NULL || dst == NULL || dstLen == NULL) { @@ -115,8 +120,6 @@ int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) } if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { HDF_LOGE("%{public}s: memcpy_s fail!", __func__); - OsalMemFree(*dst); - *dst = NULL; return HDF_FAILURE; } } @@ -134,12 +137,15 @@ int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) { (void)self; HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } @@ -147,13 +153,16 @@ int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) settings.scanStyle = SCAN_TYPE_LOW_SPAN; int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } if (ret == WIFI_HAL_SCAN_BUSY) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: StartScan return scan busy", __func__); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: StartScan successfully!", __func__); return HDF_SUCCESS; } @@ -167,16 +176,20 @@ int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, u HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: Get scan result successfully!", __func__); return HDF_SUCCESS; } @@ -189,17 +202,21 @@ int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, i HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } *networkId = ret; + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); return HDF_SUCCESS; } @@ -212,17 +229,20 @@ int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -235,16 +255,20 @@ int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -257,23 +281,14 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (name != NULL) { - HDF_LOGI("%{public}s name = %{private}s", __func__, name); - } - if (value != NULL) { - HDF_LOGI("%{public}s value = %{private}s", __func__, value); - } + HDF_LOGI("enter %{public}s networkId = %{public}d name = %{private}s value = %{private}s", __func__, networkId, + name, value); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } - struct WpaSetNetworkArgv conf; - if (memset_s(&conf, sizeof(conf), 0, sizeof(conf)) != 0) { - HDF_LOGE("%{public}s: memset_s conf fail", __func__); - return HDF_FAILURE; - } + struct WpaSetNetworkArgv conf = {0}; conf.id = networkId; int pos = -1; for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { @@ -356,20 +371,24 @@ int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); int size = MAX_NETWORKS_NUM; WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(size, sizeof(WifiNetworkInfo)); if (infos == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: info = NULL", __func__); return HDF_FAILURE; } WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); free(infos); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdListNetworks(pStaIfc, infos, &size); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdListNetworks fail! ret = %{public}d", __func__, ret); free(infos); return HDF_FAILURE; @@ -383,6 +402,7 @@ int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, } *networkInfoLen = size; free(infosTmp); + pthread_mutex_unlock(&g_interfaceLock); return HDF_SUCCESS; } @@ -395,17 +415,20 @@ int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdSelectNetwork(pStaIfc, networkId); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdSelectNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdSelectNetwork success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -418,17 +441,20 @@ int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdEnableNetwork(pStaIfc, networkId); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdEnableNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdEnableNetwork success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -441,16 +467,20 @@ int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName) HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdReconnect(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdReconnect fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdReconnect success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -463,17 +493,20 @@ int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName) HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdDisconnect(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdDisconnect fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdDisconnect success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -486,17 +519,20 @@ int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdPowerSave(pStaIfc, enable); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdPowerSave fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdPowerSave success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -509,17 +545,20 @@ int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdSetAutoConnect(pStaIfc, enable); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdSetAutoConnect fail! ret=%{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdSetAutoConnect success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -597,17 +636,21 @@ int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, s HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } struct WpaHalCmdStatus halStatus; if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { + pthread_mutex_unlock(&g_interfaceLock); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); return HDF_FAILURE; } @@ -622,6 +665,7 @@ int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, s if (status->bssidLen == 0) { HDF_LOGE("%{public}s key not include bssid", __func__); } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); return HDF_SUCCESS; } @@ -634,16 +678,20 @@ int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -673,8 +721,10 @@ int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, c HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } @@ -686,8 +736,9 @@ int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, c config.anyFlag = wpaParam->anyFlag; config.multiAp = wpaParam->multiAp; if (wpaParam->bssidLen > 0) { - if (strncpy_s(config.bssid, sizeof(config.bssid),(const char *)wpaParam->bssid, + if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, wpaParam->bssidLen) != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); return HDF_FAILURE; } @@ -695,12 +746,15 @@ int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, c ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); } if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } else if (ret == WIFI_HAL_PBC_OVERLAP) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -715,22 +769,27 @@ int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } struct WpaWpsPinArgv config = {{0}, {0}}; if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), strlen(macToStr(wpaParam->bssid))) != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -743,18 +802,21 @@ int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -769,16 +831,20 @@ int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -793,22 +859,27 @@ int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } struct WpaGetNetworkArgv getNetwork = {0}; getNetwork.id = networkId; if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: strncpy_s param fail", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -821,16 +892,20 @@ int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -843,16 +918,20 @@ int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -866,17 +945,20 @@ int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -889,19 +971,22 @@ int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int scanSsid = 0; int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); return HDF_FAILURE; } *enable = (scanSsid == 1); + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); return HDF_SUCCESS; } @@ -915,17 +1000,20 @@ int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifN HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -938,17 +1026,20 @@ int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8 HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -962,16 +1053,20 @@ int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, in HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -984,17 +1079,20 @@ int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); return HDF_SUCCESS; } @@ -1007,16 +1105,20 @@ int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); return HDF_SUCCESS; } @@ -1029,16 +1131,20 @@ int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -1613,7 +1719,6 @@ static int32_t WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo *wpaVendorExtInfo return HDF_ERR_INVALID_PARAM; } - wpaVendorInfo->data = NULL; wpaVendorInfo->type = wpaVendorExtInfo->type; wpaVendorInfo->freq = wpaVendorExtInfo->freq; wpaVendorInfo->width = wpaVendorExtInfo->width; @@ -1852,16 +1957,18 @@ int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWp int32_t ret = HDF_FAILURE; (void)self; + pthread_mutex_lock(&g_interfaceLock); if (cbFunc == NULL || ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } int nameLen = strlen(ifName); if (IsSockRemoved(ifName, nameLen) == 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("invalid opt"); return HDF_FAILURE; } - (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); do { HDF_LOGE("%{public}s: call HdfWpaAddRemoteObj", __func__); ret = HdfWpaAddRemoteObj(cbFunc, ifName); @@ -1876,7 +1983,7 @@ int32_t WpaInterfaceRegisterEventCallback(struct IWpaInterface *self, struct IWp break; } } while (0); - (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); + pthread_mutex_unlock(&g_interfaceLock); return ret; } @@ -1884,11 +1991,18 @@ int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct I const char *ifName) { (void)self; + pthread_mutex_lock(&g_interfaceLock); if (cbFunc == NULL || ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - (void)OsalMutexLock(&HdfWpaStubDriver()->mutex); + int nameLen = strlen(ifName); + if (IsSockRemoved(ifName, nameLen) == 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("invalid opt"); + return HDF_FAILURE; + } HdfWpaDelRemoteObj(cbFunc); if (DListIsEmpty(&HdfWpaStubDriver()->remoteListHead)) { int32_t ret = WpaUnregisterEventCallback(HdfWpaCallbackFun, WIFI_WPA_TO_HAL_CLIENT, ifName); @@ -1896,7 +2010,7 @@ int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct I HDF_LOGE("%{public}s: Unregister failed!, error code: %{public}d", __func__, ret); } } - (void)OsalMutexUnlock(&HdfWpaStubDriver()->mutex); + pthread_mutex_unlock(&g_interfaceLock); return HDF_SUCCESS; } @@ -2015,10 +2129,10 @@ int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { return HDF_FAILURE; } - } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { + } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { + CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { return HDF_FAILURE; } } else { @@ -2033,10 +2147,14 @@ int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } + int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName) { (void)self; + HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM ; } @@ -2048,6 +2166,7 @@ int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifNam return HDF_FAILURE; } ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); } @@ -2075,11 +2194,20 @@ int32_t WpaInterfaceStart(struct IWpaInterface *self) (void)self; HDF_LOGI("enter %{public}s: wpa_supplicant begin to start", __func__); + InitWifiWpaGlobalInterface(); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGI("fail get global interface"); + return HDF_FAILURE; + } + pthread_mutex_lock(&g_interfaceLock); ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(&g_interfaceLock); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__); return HDF_SUCCESS; } @@ -2089,13 +2217,16 @@ int32_t WpaInterfaceStop(struct IWpaInterface *self) int32_t ret; (void)self; + pthread_mutex_lock(&g_interfaceLock); HDF_LOGI("enter %{public}s: wpa_supplicant begin to stop", __func__); ret = StopWpaSupplicant(); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(&g_interfaceLock); return HDF_FAILURE; } ReleaseWifiStaInterface(0); + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); return HDF_SUCCESS; } @@ -2104,20 +2235,25 @@ int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName) { (void)self; HDF_LOGI("enter %{public}s ", __func__); + pthread_mutex_lock(&g_interfaceLock); if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdReassociate(pStaIfc); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdReassociate fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdReassociate success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -2126,20 +2262,25 @@ int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, { (void)self; HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); if (ifName == NULL || cmd == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdStaShellCmd(pStaIfc, cmd); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: fail ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: success", __func__); return HDF_SUCCESS; } diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 94281d61fb..0c58322dd4 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -52,7 +52,6 @@ #define WIFI_NETWORK_CONFIG_VALUE_LENGTH 2048 #define CMD_LEN 6 - int32_t WpaInterfaceStart(struct IWpaInterface *self); int32_t WpaInterfaceStop(struct IWpaInterface *self); int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) ; @@ -110,6 +109,8 @@ int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName); int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd); int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen); +pthread_mutex_t *GetInterfaceLock(); + const char *macToStr(const u8 *addr); struct StWpaMainParam { int argc; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c index dde03e0236..d2964662cd 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c @@ -31,11 +31,8 @@ #include "wifi_display.h" #include "bssid_ignore.h" #include "config.h" - - #include "v1_1/iwpa_callback.h" #include "v1_1/iwpa_interface.h" - #include "wpa_p2p_hal.h" #define HEX_TO_DEC_MOVING 4 @@ -120,16 +117,20 @@ int32_t WpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface *self, const char HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetSsidPostfixName(pMainIfc, name); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -142,16 +143,20 @@ int32_t WpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface *self, const char * HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsDeviceType(pMainIfc, type); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -164,16 +169,20 @@ int32_t WpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface *self, const cha HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsConfigMethods(pMainIfc, methods); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -186,21 +195,26 @@ int32_t WpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface *self, const char *i HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pGroupIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetGroupIdle(pGroupIfc, time); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -210,16 +224,20 @@ int32_t WpaInterfaceP2pSetWfdEnable(struct IWpaInterface *self, const char *ifNa HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdEnable(pMainIfc, enable); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -229,16 +247,20 @@ int32_t WpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface *self, const HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetPersistentReconnect(pMainIfc, status); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -251,16 +273,20 @@ int32_t WpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface *self, con HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsSecDeviceType(pMainIfc, type); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -273,21 +299,26 @@ int32_t WpaInterfaceP2pSetupWpsPbc(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pGroupIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPbc(pGroupIfc, address); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -302,8 +333,16 @@ int32_t WpaInterfaceP2pSetupWpsPin(struct IWpaInterface *self, const char *ifNam return HDF_FAILURE; } - P2pWpsPinDisplayArgv p2pWpsPinDisplay; - if (memset_s(&p2pWpsPinDisplay, sizeof(p2pWpsPinDisplay), 0, sizeof(p2pWpsPinDisplay)) != EOK) { + P2pWpsPinDisplayArgv p2pWpsPinDisplay = {0}; + WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); + WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); + if (pMainIfc == NULL || pGroupIfc == NULL) { + HDF_LOGE("%{public}s: pMainIfc or pGroupIfc is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPin(pGroupIfc, &p2pWpsPinDisplay); + if (ret != P2P_SUP_ERRCODE_SUCCESS) { + HDF_LOGE("WpaP2pCliCmdWpsPin fail, ret = %{public}d", ret); return HDF_FAILURE; } if (strlen(pin) > 0) { @@ -314,32 +353,12 @@ int32_t WpaInterfaceP2pSetupWpsPin(struct IWpaInterface *self, const char *ifNam } } else { p2pWpsPinDisplay.mode = P2P_PIN_DISPLAY; - if (strncpy_s(p2pWpsPinDisplay.bssid, sizeof(p2pWpsPinDisplay.bssid), address, strlen(address)) != EOK) { + if ((strncpy_s(p2pWpsPinDisplay.bssid, sizeof(p2pWpsPinDisplay.bssid), address, strlen(address)) != EOK) || + (strncpy_s(result, resultLen, p2pWpsPinDisplay.pinCode, strlen(p2pWpsPinDisplay.pinCode)) != EOK)) { HDF_LOGE("%{public}s: Failed to init request message, the input message may be invalid!", __func__); return HDF_FAILURE; } } - WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); - if (pMainIfc == NULL) { - HDF_LOGE("%{public}s: pMainIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); - if (pGroupIfc == NULL) { - HDF_LOGE("%{public}s: pGroupIfc is null", __func__); - return HDF_ERR_INVALID_PARAM; - } - P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdWpsPin(pGroupIfc, &p2pWpsPinDisplay); - if (ret != P2P_SUP_ERRCODE_SUCCESS) { - HDF_LOGE("WpaP2pCliCmdWpsPin fail, ret = %{public}d", ret); - return HDF_FAILURE; - } - if (p2pWpsPinDisplay.mode == P2P_PIN_DISPLAY) { - if (strncpy_s(result, resultLen, p2pWpsPinDisplay.pinCode, strlen(p2pWpsPinDisplay.pinCode)) != EOK) { - HDF_LOGE("%{public}s: Failed to return pin code!", __func__); - return HDF_FAILURE; - } - } HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -352,21 +371,26 @@ int32_t WpaInterfaceP2pSetPowerSave(struct IWpaInterface *self, const char *ifNa HDF_LOGE("P2pSetPowerSave, groupIfc is NULL"); return HDF_FAILURE; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } WifiWpaP2pGroupInterface *pGroupIfc = GetWifiWpaP2pGroupInterface(ifName); if (pGroupIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pGroupIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pGroupIfc->wpaP2pCliCmdSetPowerSave(pGroupIfc, enable); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -379,16 +403,20 @@ int32_t WpaInterfaceP2pSetDeviceName(struct IWpaInterface *self, const char *ifN HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWpsName(pMainIfc, name); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -401,16 +429,20 @@ int32_t WpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface *self, const char HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetWfdDeviceInfo(pMainIfc, config); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -420,16 +452,20 @@ int32_t WpaInterfaceP2pSetRandomMac(struct IWpaInterface *self, const char *ifNa HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetRandomMac(pMainIfc, networkId); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -439,16 +475,20 @@ int32_t WpaInterfaceP2pStartFind(struct IWpaInterface *self, const char *ifName, HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pFound(pMainIfc, timeout); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -459,16 +499,20 @@ int32_t WpaInterfaceP2pSetExtListen(struct IWpaInterface *self, const char *ifNa HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdExtListen(pMainIfc, enable, period, interval); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -479,16 +523,20 @@ int32_t WpaInterfaceP2pSetListenChannel(struct IWpaInterface *self, const char * HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetListenChannel(pMainIfc, channel, regClass); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -502,23 +550,28 @@ int32_t WpaInterfaceP2pProvisionDiscovery(struct IWpaInterface *self, const char HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); P2pProvisionDiscoveryArgv p2pProvision; if (memset_s(&p2pProvision, sizeof(p2pProvision), 0, sizeof(p2pProvision)) != EOK || strncpy_s(p2pProvision.peerbssid, sizeof(p2pProvision.peerbssid), peerBssid, strlen(peerBssid)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("Failed to init request message, the input message may be invalid!"); return HDF_FAILURE; } p2pProvision.mode = mode; WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdProvisionDiscovery(pMainIfc, &p2pProvision); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -529,16 +582,20 @@ int32_t WpaInterfaceP2pAddGroup(struct IWpaInterface *self, const char *ifName, HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGroupAdd(pMainIfc, isPersistent, networkId, freq); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -552,16 +609,20 @@ int32_t WpaInterfaceP2pAddService(struct IWpaInterface *self, const char *ifName HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceAdd(pMainIfc, info); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -575,16 +636,20 @@ int32_t WpaInterfaceP2pRemoveService(struct IWpaInterface *self, const char *ifN HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServiceDel(pMainIfc, info); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -594,16 +659,20 @@ int32_t WpaInterfaceP2pStopFind(struct IWpaInterface *self, const char *ifName) HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pStopFind(pMainIfc); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -613,16 +682,20 @@ int32_t WpaInterfaceP2pFlush(struct IWpaInterface *self, const char *ifName) HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlush(pMainIfc); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -632,16 +705,20 @@ int32_t WpaInterfaceP2pFlushService(struct IWpaInterface *self, const char *ifNa HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdFlushService(pMainIfc); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -651,16 +728,20 @@ int32_t WpaInterfaceP2pRemoveNetwork(struct IWpaInterface *self, const char *ifN HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRemoveNetwork(pMainIfc, networkId); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -677,16 +758,20 @@ int32_t WpaInterfaceP2pSetGroupConfig(struct IWpaInterface *self, const char *if HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET_NETWORK %d %s %s", ifName, networkId, name, value); if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); return HDF_FAILURE; } if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s command failed!", __func__); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -700,25 +785,30 @@ int32_t WpaInterfaceP2pInvite(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: peerBssid, goBssid and ifname have NULL", __func__); return HDF_FAILURE; } + pthread_mutex_lock(GetInterfaceLock()); P2pHalInviteArgv p2pHalInvite; if (memset_s(&p2pHalInvite, sizeof(p2pHalInvite), 0, sizeof(p2pHalInvite)) != EOK || strncpy_s(p2pHalInvite.peerbssid, sizeof(p2pHalInvite.peerbssid), peerBssid, strlen(peerBssid)) != EOK || strncpy_s(p2pHalInvite.gobssid, sizeof(p2pHalInvite.gobssid), goBssid, strlen(goBssid)) != EOK || strncpy_s(p2pHalInvite.ifname, sizeof(p2pHalInvite.ifname), ifName, strlen(ifName)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("Failed to init request message, the input message may be invalid!"); return HDF_FAILURE; } p2pHalInvite.persistent = 0; WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdInvite(pMainIfc, &p2pHalInvite); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -732,23 +822,28 @@ int32_t WpaInterfaceP2pReinvoke(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); P2pHalReInviteArgv p2pHalReInvite; if (memset_s(&p2pHalReInvite, sizeof(p2pHalReInvite), 0, sizeof(p2pHalReInvite)) != EOK || strncpy_s(p2pHalReInvite.peerbssid, sizeof(p2pHalReInvite.peerbssid), bssid, strlen(bssid)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("Failed to init request message, the input message may be invalid!"); return HDF_FAILURE; } p2pHalReInvite.networkId = networkId; WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdReInvite(pMainIfc, &p2pHalReInvite); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -762,16 +857,20 @@ int32_t WpaInterfaceP2pGetDeviceAddress(struct IWpaInterface *self, const char * return HDF_ERR_INVALID_PARAM; } (void)self; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGetDeviceAddress(pMainIfc, deviceAddress, deviceAddressLen); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -786,21 +885,26 @@ int32_t WpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface *self, const cha } (void)self; char seq[WIFI_P2P_SERVER_DISCOVERY_SEQUENCE_LENGTH] = {0}; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscReq(pMainIfc, (char *)reqService->bssid, (char *)reqService->msg, seq, sizeof(seq)); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } if (strncpy_s(replyDisc, replyDiscLen, seq, strlen(seq)) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail", __func__); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -813,16 +917,20 @@ int32_t WpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface *self, const HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdServDiscCancelReq(pMainIfc, id); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -836,16 +944,20 @@ int32_t WpaInterfaceP2pRespServerDiscovery(struct IWpaInterface *self, const cha return HDF_ERR_INVALID_PARAM; } (void)self; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdRespServerDiscovery(pMainIfc, info); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("WpaP2pCliCmdRespServerDiscovery fail, ret = %{public}d", ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -858,6 +970,7 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); char *reply; const int replySize = REPLY_SIZE; char cmd[CMD_SIZE] = {0}; @@ -866,17 +979,20 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c char pin[CMD_SIZE] = {0}; char peerDevAddr[CMD_SIZE] = {0}; if (memcpy_s(pin, CMD_SIZE, info->pin, CMD_SIZE) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s strcpy failed", __func__); return HDF_FAILURE; } if (memcpy_s(peerDevAddr, CMD_SIZE, info->peerDevAddr, CMD_SIZE) != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s strcpy failed", __func__); return HDF_FAILURE; } reply = (char *)malloc(replySize); if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is NULL!", __func__); return HDF_FAILURE; } @@ -890,6 +1006,7 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c } } else { if (snprintf_s(join, sizeof(join), sizeof(join) - 1, " go_intent=%d", info->goIntent) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s input parameter invalid!", __func__); free(reply); return HDF_ERR_INVALID_PARAM; @@ -909,6 +1026,7 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c HDF_LOGE("%{public}s strcpy failed", __func__); } } else { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s Mode value is invalid %{public}d!", __func__, info->provdisc); free(reply); return HDF_ERR_INVALID_PARAM; @@ -920,30 +1038,34 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c macToStr(info->peerDevAddr), pin, mode, persistent, join); } if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); free(reply); return HDF_FAILURE; } if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("P2P_CONNECT command failed!"); free(reply); return HDF_FAILURE; } if (strncmp(reply, "FAIL", strlen("FAIL")) == 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s P2p connect return %{public}s", __func__, reply); free(reply); return HDF_FAILURE; } if (info->provdisc == P2P_WPS_METHOD_DISPLAY && strcmp((char *)info->pin, "pin") == 0) { if (strncpy_s(replyPin, replyPinLen, reply, strlen(reply)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s Failed to copy response pin code info!", __func__); free(reply); return HDF_FAILURE; } } - + pthread_mutex_unlock(GetInterfaceLock()); free(reply); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; @@ -957,7 +1079,7 @@ int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifNa HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(GetInterfaceLock()); char cmd[CMD_SIZE]; char buf[CMD_SIZE]; (void)self; @@ -970,18 +1092,21 @@ int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifNa HDF_LOGI("hid2dconnect freq=%{public}d, isLegacyGo=%{public}d", freq, isLegacyGo); if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s MAGICLINK \"%s\"\n%s\n\"%s\"\n%d\n%d", ifName, (char *)info->ssid, macToStr(info->bssid), (char *)info->passphrase, freq, isLegacyGo) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s.", __func__, cmd); return HDF_FAILURE; } if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("hid2d_connect command failed!"); return HDF_FAILURE; } if (strncmp(buf, "FAIL", strlen("FAIL")) == 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: return %{public}s", __func__, buf); return HDF_FAILURE; } - + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -991,16 +1116,20 @@ int32_t WpaInterfaceP2pSetServDiscExternal(struct IWpaInterface *self, const cha HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdSetServDiscExternal(pMainIfc, mode); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("WpaP2pCliCmdSetServDiscExternal fail, ret = %{public}d", ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1013,16 +1142,20 @@ int32_t WpaInterfaceP2pRemoveGroup(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdP2pRemoveGroup(pMainIfc, groupName); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1032,16 +1165,20 @@ int32_t WpaInterfaceP2pCancelConnect(struct IWpaInterface *self, const char *ifN HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdCancelConnect(pMainIfc); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1058,16 +1195,19 @@ int32_t WpaInterfaceP2pGetGroupConfig(struct IWpaInterface *self, const char *if HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(GetInterfaceLock()); ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s GET_NETWORK %d %s", ifName, networkId, param); if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); return HDF_FAILURE; } if (WpaCliCmd(cmd, value, valueLen) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("GET_NETWORK command failed!"); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1080,16 +1220,20 @@ int32_t WpaInterfaceP2pAddNetwork(struct IWpaInterface *self, const char *ifName return HDF_ERR_INVALID_PARAM; } (void)self; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdAddNetwork(pMainIfc, networkId); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("WpaP2pCliCmdAddNetwork fail, ret = %{public}d", ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1102,12 +1246,14 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); char *reply; const int replySize = REPLY_SIZE; char cmd[CMD_SIZE]; reply = (char *)malloc(replySize); if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is NULL!", __func__); return HDF_FAILURE; } @@ -1117,18 +1263,21 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); free(reply); return HDF_FAILURE; } if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("P2P_PEER command failed!"); free(reply); return HDF_FAILURE; } if (strstr(reply, "\n") == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is error", __func__); free(reply); return HDF_FAILURE; @@ -1137,6 +1286,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c char *token = strtok_r(reply, "\n", &savedPtr); info->srcAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); if (info->srcAddress == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc srcAddress failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1144,6 +1294,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } info->p2pDeviceAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); if (info->p2pDeviceAddress == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc p2pDeviceAddress failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1151,6 +1302,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } info->primaryDeviceType = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_TYPE_LENGTH); if (info->primaryDeviceType == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc primaryDeviceType failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1158,6 +1310,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } info->deviceName = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); if (info->deviceName == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc deviceName failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1165,6 +1318,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } info->wfdDeviceInfo = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_WFD_DEVICE_INFO_LENGTH); if (info->wfdDeviceInfo == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc wfdDeviceInfo failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1172,6 +1326,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } info->operSsid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH); if (info->operSsid == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc operSsid failed!"); free(reply); HdiP2pDeviceInfoFree(info, false); @@ -1212,6 +1367,7 @@ int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, c } token = strtok_r(NULL, "\n", &savedPtr); } + pthread_mutex_unlock(GetInterfaceLock()); free(reply); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; @@ -1225,12 +1381,14 @@ int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); char *reply; const int replySize = REPLY_SIZE; char cmd[CMD_SIZE]; reply = (char *)malloc(replySize); if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is NULL!", __func__); return HDF_FAILURE; } @@ -1240,18 +1398,21 @@ int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PEER %s", ifName, bssid); if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); free(reply); return HDF_FAILURE; } if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("P2P_PEER command failed!"); free(reply); return HDF_FAILURE; } if (strstr(reply, "\n") == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is error", __func__); free(reply); return HDF_FAILURE; @@ -1267,6 +1428,7 @@ int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char } token = strtok_r(NULL, "\n", &savedPtr); } + pthread_mutex_unlock(GetInterfaceLock()); free(reply); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; @@ -1280,22 +1442,26 @@ int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifNa HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } + pthread_mutex_lock(GetInterfaceLock()); char *reply; const int replySize = REPLY_SIZE; char cmd[CMD_SIZE]; reply = (char *)malloc(replySize); if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is NULL!", __func__); return HDF_FAILURE; } (void)self; if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s LIST_NETWORKS", ifName) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("snprintf err"); free(reply); return HDF_FAILURE; } if (WpaCliCmd(cmd, reply, REPLY_SIZE) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("LIST_NETWORKS command failed!"); free(reply); return HDF_FAILURE; @@ -1303,6 +1469,7 @@ int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifNa char *token = strstr(reply, "\n"); if (token == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s token is NULL!", __func__); free(reply); return HDF_FAILURE; @@ -1313,12 +1480,14 @@ int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifNa ++tmpPos; } if (infoList->infoNum <= 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s infoList->infoNum <= 0", __func__); free(reply); return HDF_FAILURE; } infoList->infos = (struct HdiP2pNetworkInfo *)OsalMemCalloc(sizeof(struct HdiP2pNetworkInfo) * infoList->infoNum); if (infoList->infos == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("malloc infos failed!"); free(reply); return HDF_FAILURE; @@ -1357,7 +1526,7 @@ int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifNa index++; token = strtok_r(NULL, "\n", &savedPtr); } - + pthread_mutex_unlock(GetInterfaceLock()); free(reply); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; @@ -1368,16 +1537,20 @@ int32_t WpaInterfaceP2pSaveConfig(struct IWpaInterface *self, const char *ifName HDF_LOGI("Ready to enter hdi %{public}s", __func__); (void)self; (void)ifName; + pthread_mutex_lock(GetInterfaceLock()); WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName); if (pMainIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: pMainIfc is null", __func__); return HDF_ERR_INVALID_PARAM; } P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdStoreConfig(pMainIfc); if (ret != P2P_SUP_ERRCODE_SUCCESS) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: fail, ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1396,17 +1569,20 @@ int32_t WpaInterfaceDeliverP2pData(struct IWpaInterface *self, const char *ifNam HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - + pthread_mutex_lock(GetInterfaceLock()); ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_DELIVER_DATA cmdType=%d dataType=%d carryData=%s", ifName, cmdType, dataType, carryData); if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s, count = %{public}d", __func__, cmd, ret); return HDF_FAILURE; } if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s command failed!", __func__); return HDF_FAILURE; } + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s success", __func__); return HDF_SUCCESS; } @@ -1421,29 +1597,37 @@ int32_t WpaInterfaceVendorExtProcessCmd(struct IWpaInterface *self, const char * HDF_LOGE("%{public}s input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM ; } - + pthread_mutex_lock(GetInterfaceLock()); char *reply; const int replySize = REPLY_SIZE; reply = (char *)malloc(replySize); if (reply == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s reply is NULL!", __func__); return HDF_FAILURE; } char newCmd[NEW_CMD_MAX_LEN] = {0}; if (snprintf_s(newCmd, sizeof(newCmd), sizeof(newCmd) - 1, "IFNAME=%s %s", ifName, cmd) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s: snprintf_s is failed, error code: %{public}d", __func__, ret); free(reply); return HDF_FAILURE; } if (WpaCliCmd(newCmd, reply, replySize) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s WpaCliCmd failed!", __func__); free(reply); return HDF_FAILURE; } +<<<<<<< HEAD HDF_LOGI("%{public}s reply %{public}s !", __func__, reply); +======= + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s cmd %{public}s reply %{public}s !", __func__, newCmd, reply); +>>>>>>> da9bf65ec (TicketNo:DTS2024081411562) ret = atoi(reply); free(reply); return ret; -- Gitee From 80b2eb768c7f6f0f6ad39e96de80da6c996b6950 Mon Sep 17 00:00:00 2001 From: xionglei Date: Wed, 21 Aug 2024 10:09:52 +0000 Subject: [PATCH 0290/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index 1e5aedf9cf..573bf18fd5 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -291,6 +291,7 @@ void ReleaseIfaceCtrl(char *ifName, int len) } if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { ReleaseWpaCtrl(&(g_wpaInterface->staCtrl)); + ReleaseWpaCtrl(&(g_wpaInterface->p2pCtrl)); ReleaseWpaCtrl(&(g_wpaInterface->chbaCtrl)); #ifndef OHOS_EUPDATER ReleaseEventCallback(); -- Gitee From adefe09c859942e50deb4b81ed8aa8bfb53caadf Mon Sep 17 00:00:00 2001 From: luzhiye Date: Thu, 22 Aug 2024 02:35:19 +0000 Subject: [PATCH 0291/1485] update usb/ddk/device/src/adapter_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 9daf386460..c6a68d270c 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -346,7 +346,7 @@ static int32_t UsbFnAdapterCreatInterface(const char *interfaceName, int32_t nam ret = snprintf_s(fnnew.name, MAX_NAMELEN, MAX_NAMELEN - 1, "%s", interfaceName); if (ret < 0) { HDF_LOGE("%{public}s: snprintf_s failed", __func__); - UsbFnAdapterCloseFn(fd); + UsbFnAdapterClosefn(fd); return HDF_ERR_IO; } ret = ioctl(fd, FUNCTIONFS_NEWFN, &fnnew); -- Gitee From 4ea11f5bb76c2efcb6bdf1613197155980fc89c4 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 01:38:06 +0000 Subject: [PATCH 0292/1485] update wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c. Signed-off-by: xionglei --- wlan/wpa/interfaces/hdi_service/BUILD.gn | 1 + wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c | 1 + .../interfaces/hdi_service/service_common/wpa_common_cmd_ext.c | 0 wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c | 3 --- 4 files changed, 2 insertions(+), 3 deletions(-) create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c diff --git a/wlan/wpa/interfaces/hdi_service/BUILD.gn b/wlan/wpa/interfaces/hdi_service/BUILD.gn index f75db99456..ab845f4cce 100644 --- a/wlan/wpa/interfaces/hdi_service/BUILD.gn +++ b/wlan/wpa/interfaces/hdi_service/BUILD.gn @@ -30,6 +30,7 @@ if (is_standard_system) { "service_common/hdi_wpa_common.c", "service_common/hdi_wpa_hal.c", "service_common/wpa_common_cmd.c", + "service_common/wpa_common_cmd_ext.c", "service_common/wpa_hdi_util.c", "service_common/wpa_p2p_cmd.c", "service_common/wpa_p2p_hal.c", diff --git a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c index 573bf18fd5..bd644b91a2 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/hdi_wpa_hal.c @@ -209,6 +209,7 @@ void InitWifiWpaGlobalInterface(void) } g_wpaInterface->wpaCliConnect = WpaCliConnect; g_wpaInterface->wpaCliClose = WpaCliClose; + g_wpaInterface->wpaCliAddIface = WpaCliAddIface; g_wpaInterface->wpaCliRemoveIface = WpaCliRemoveIface; g_wpaInterface->wpaCliTerminate = WpaCliWpaTerminate; g_wpaInterface->ifaces = NULL; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c new file mode 100644 index 0000000000..e69de29bb2 diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c index d2964662cd..88d79531d0 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c @@ -1621,13 +1621,10 @@ int32_t WpaInterfaceVendorExtProcessCmd(struct IWpaInterface *self, const char * free(reply); return HDF_FAILURE; } -<<<<<<< HEAD HDF_LOGI("%{public}s reply %{public}s !", __func__, reply); -======= pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s cmd %{public}s reply %{public}s !", __func__, newCmd, reply); ->>>>>>> da9bf65ec (TicketNo:DTS2024081411562) ret = atoi(reply); free(reply); return ret; -- Gitee From 6a9b9eb228eb5dda76e255faa66e824f217ff6eb Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 06:34:07 +0000 Subject: [PATCH 0293/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd.c | 185 ------------- .../service_common/wpa_common_cmd_ext.c | 260 ++++++++++++++++++ 2 files changed, 260 insertions(+), 185 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 5736767755..e1f8dc2f04 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -100,39 +100,6 @@ int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_L return flag; } -pthread_mutex_t *GetInterfaceLock() -{ - return &g_interfaceLock; -} - -int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) -{ - if (src == NULL || dst == NULL || dstLen == NULL) { - HDF_LOGE("%{public}s: Invalid parameter!", __func__); - return HDF_ERR_INVALID_PARAM; - } - HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); - if (srcLen > 0) { - *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); - if (*dst == NULL) { - HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); - return HDF_FAILURE; - } - if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { - HDF_LOGE("%{public}s: memcpy_s fail!", __func__); - return HDF_FAILURE; - } - } - *dstLen = srcLen; - return HDF_SUCCESS; -} - -struct HdfWpaStubData *HdfWpaStubDriver(void) -{ - static struct HdfWpaStubData registerManager; - return ®isterManager; -} - int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) { (void)self; @@ -167,112 +134,6 @@ int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) return HDF_SUCCESS; } -int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, - uint32_t *resultBufLen) -{ - HDF_LOGI("enter %{public}s", __func__); - (void)self; - if (ifName == NULL || resultBuf == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: Get scan result successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - if (ifName == NULL || networkId == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - *networkId = ret; - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId, const char *name, const char *value) { @@ -315,52 +176,6 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } -static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) -{ - int32_t ret = HDF_SUCCESS; - - if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { - HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); - if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, - tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, - (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, - (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill flags fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWifiWpaNetworkInfo->bssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->bssid); - hdiWifiWpaNetworkInfo->bssid = NULL; - } - if (hdiWifiWpaNetworkInfo->ssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->ssid); - hdiWifiWpaNetworkInfo->ssid = NULL; - } - if (hdiWifiWpaNetworkInfo->flags != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->flags); - hdiWifiWpaNetworkInfo->flags = NULL; - } - } - return ret; -} - //need to check int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index e69de29bb2..439e14e513 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -0,0 +1,260 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "wpa_common_cmd.h" +#include "wpa_p2p_cmd.h" +#include "hdi_wpa_hal.h" +#include +#include +#include +#include +#include +#include +#include "utils/common.h" +#include "wpa_supplicant_i.h" +#include "ctrl_iface.h" +#include "main.h" +#include "wps_supplicant.h" +#include "bssid_ignore.h" +#include "wpa_supplicant/config.h" +#include "common/defs.h" +#include "v1_1/iwpa_callback.h" +#include "v1_1/iwpa_interface.h" +#include "wpa_client.h" +#include +#include +#include +#include +#include "hdi_wpa_common.h" + +extern pthread_mutex_t g_interfaceLock; + +pthread_mutex_t *GetInterfaceLock() +{ + return &g_interfaceLock; +} + +int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) +{ + if (src == NULL || dst == NULL || dstLen == NULL) { + HDF_LOGE("%{public}s: Invalid parameter!", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); + if (srcLen > 0) { + *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); + if (*dst == NULL) { + HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); + return HDF_FAILURE; + } + if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { + HDF_LOGE("%{public}s: memcpy_s fail!", __func__); + return HDF_FAILURE; + } + } + *dstLen = srcLen; + return HDF_SUCCESS; +} + +struct HdfWpaStubData *HdfWpaStubDriver(void) +{ + static struct HdfWpaStubData registerManager; + return ®isterManager; +} + +int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + pthread_mutex_lock(&g_interfaceLock); + if (ifName == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + ScanSettings settings = {0}; + settings.scanStyle = SCAN_TYPE_LOW_SPAN; + int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + if (ret == WIFI_HAL_SCAN_BUSY) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: StartScan return scan busy", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: StartScan successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, + uint32_t *resultBufLen) +{ + HDF_LOGI("enter %{public}s", __func__); + (void)self; + if (ifName == NULL || resultBuf == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: Get scan result successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL || networkId == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + *networkId = ret; + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +{ + int32_t ret = HDF_SUCCESS; + + if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { + HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); + if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, + tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, + (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, + (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill flags fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWifiWpaNetworkInfo->bssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->bssid); + hdiWifiWpaNetworkInfo->bssid = NULL; + } + if (hdiWifiWpaNetworkInfo->ssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->ssid); + hdiWifiWpaNetworkInfo->ssid = NULL; + } + if (hdiWifiWpaNetworkInfo->flags != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->flags); + hdiWifiWpaNetworkInfo->flags = NULL; + } + } + return ret; +} \ No newline at end of file -- Gitee From bd183afedc9dc6dac42f0a672b984c7814aeef9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B1=85=E5=87=AF?= Date: Thu, 22 Aug 2024 14:48:14 +0800 Subject: [PATCH 0294/1485] fix:revert First unlock auth must be pinAuth MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 居凯 Change-Id: Ie4c3d628e8fdcc85e2ba96cb49d4963095246683 --- .../hdi_service/database/inc/idm_common.h | 1 - .../hdi_service/database/inc/idm_database.h | 2 -- .../hdi_service/database/src/idm_database.c | 26 ------------------- .../service/user_auth_interface_service.cpp | 20 -------------- .../user_auth/src/user_auth_funcs.c | 12 --------- 5 files changed, 61 deletions(-) diff --git a/user_auth/hdi_service/database/inc/idm_common.h b/user_auth/hdi_service/database/inc/idm_common.h index e84e647d2f..1ba22adc20 100644 --- a/user_auth/hdi_service/database/inc/idm_common.h +++ b/user_auth/hdi_service/database/inc/idm_common.h @@ -52,7 +52,6 @@ typedef struct { LinkedList *credentialInfoList; LinkedList *enrolledInfoList; int32_t userType; - bool hasSuccessPinAuth; } UserInfo; typedef struct { diff --git a/user_auth/hdi_service/database/inc/idm_database.h b/user_auth/hdi_service/database/inc/idm_database.h index 5e313e49c4..337301b8ad 100644 --- a/user_auth/hdi_service/database/inc/idm_database.h +++ b/user_auth/hdi_service/database/inc/idm_database.h @@ -55,8 +55,6 @@ ResultCode GetSecureUid(int32_t userId, uint64_t *secUid); ResultCode GetEnrolledInfo(int32_t userId, EnrolledInfoHal **enrolledInfos, uint32_t *num); ResultCode GetEnrolledInfoAuthType(int32_t userId, uint32_t authType, EnrolledInfoHal *enrolledInfo); ResultCode DeleteUserInfo(int32_t userId, LinkedList **creds); -ResultCode SetHasSuccessPinAuth(int32_t userId, bool hasSuccessPinAuth); -ResultCode GetHasSuccessPinAuth(int32_t userId, bool *hasSuccessPinAuth); LinkedList *QueryCredentialLimit(const CredentialCondition *limit); ResultCode QueryCredentialUserId(uint64_t credentialId, int32_t *userId); diff --git a/user_auth/hdi_service/database/src/idm_database.c b/user_auth/hdi_service/database/src/idm_database.c index d7a29c4368..8f80cea6b5 100644 --- a/user_auth/hdi_service/database/src/idm_database.c +++ b/user_auth/hdi_service/database/src/idm_database.c @@ -245,32 +245,6 @@ IAM_STATIC UserInfo *QueryUserInfo(int32_t userId) return NULL; } -ResultCode SetHasSuccessPinAuth(int32_t userId, bool hasSuccessPinAuth) -{ - UserInfo *user = QueryUserInfo(userId); - if (user == NULL) { - LOG_ERROR("can't find this user"); - return RESULT_NOT_FOUND; - } - user->hasSuccessPinAuth = hasSuccessPinAuth; - return RESULT_SUCCESS; -} - -ResultCode GetHasSuccessPinAuth(int32_t userId, bool *hasSuccessPinAuth) -{ - if (hasSuccessPinAuth == NULL) { - LOG_ERROR("bad param"); - return RESULT_BAD_PARAM; - } - UserInfo *user = QueryUserInfo(userId); - if (user == NULL) { - LOG_ERROR("can't find this user"); - return RESULT_NOT_FOUND; - } - *hasSuccessPinAuth = user->hasSuccessPinAuth; - return RESULT_SUCCESS; -} - IAM_STATIC ResultCode GetAllEnrolledInfoFromUser(UserInfo *userInfo, EnrolledInfoHal **enrolledInfos, uint32_t *num) { LinkedList *enrolledInfoList = userInfo->enrolledInfoList; diff --git a/user_auth/hdi_service/service/user_auth_interface_service.cpp b/user_auth/hdi_service/service/user_auth_interface_service.cpp index 1d8eb444bb..cea607d5fc 100644 --- a/user_auth/hdi_service/service/user_auth_interface_service.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_service.cpp @@ -498,21 +498,6 @@ static int32_t CopyAuthParamToHal(uint64_t contextId, const HdiAuthParam ¶m, return RESULT_SUCCESS; } -static int32_t CheckFirstAuthType(int32_t userId, uint32_t authType) -{ - bool hasSuccessPinAuth = false; - ResultCode ret = GetHasSuccessPinAuth(userId, &hasSuccessPinAuth); - if (ret != RESULT_SUCCESS) { - LOG_ERROR("GetHasSuccessPinAuth failed"); - return ret; - } - if (hasSuccessPinAuth == false && authType != PIN_AUTH) { - LOG_ERROR("first auth type must be pinAuth"); - return RESULT_TYPE_NOT_SUPPORT; - } - return RESULT_SUCCESS; -} - int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const HdiAuthParam ¶m, std::vector &infos) { @@ -535,11 +520,6 @@ int32_t UserAuthInterfaceService::BeginAuthentication(uint64_t contextId, const IAM_LOGE("get null schedule"); return RESULT_GENERAL_ERROR; } - ret = CheckFirstAuthType(paramHal.userId, paramHal.authType); - if (ret != RESULT_SUCCESS) { - DestroyLinkedList(schedulesGet); - return ret; - } LinkedListNode *tempNode = schedulesGet->head; while (tempNode != nullptr) { if (tempNode->data == nullptr) { diff --git a/user_auth/hdi_service/user_auth/src/user_auth_funcs.c b/user_auth/hdi_service/user_auth/src/user_auth_funcs.c index c46f0a154b..f94e474fb9 100644 --- a/user_auth/hdi_service/user_auth/src/user_auth_funcs.c +++ b/user_auth/hdi_service/user_auth/src/user_auth_funcs.c @@ -132,18 +132,6 @@ IAM_STATIC ResultCode HandleAuthSuccessResult(const UserAuthContext *context, co result->credentialDigest = enrolledState.credentialDigest; result->credentialCount = enrolledState.credentialCount; } - if (result->result == RESULT_SUCCESS && context->authType == PIN_AUTH) { - bool hasSuccessPinAuth = false; - ResultCode ret = GetHasSuccessPinAuth(context->userId, &hasSuccessPinAuth); - if (ret != RESULT_SUCCESS) { - LOG_ERROR("GetHasSuccessPinAuth failed"); - return ret; - } - if (hasSuccessPinAuth == false) { - LOG_INFO("hasSuccessPinAuth: %d", hasSuccessPinAuth); - SetHasSuccessPinAuth(context->userId, true); - } - } if (result->result == RESULT_SUCCESS && context->authType == PIN_AUTH && memcmp(context->localUdid, context->collectorUdid, sizeof(context->localUdid)) == 0) { result->rootSecret = CopyBuffer(info->rootSecret); -- Gitee From 7234983e5cc675da94a190ffc8853bcbce3545c2 Mon Sep 17 00:00:00 2001 From: xiaosi Date: Thu, 22 Aug 2024 15:09:57 +0800 Subject: [PATCH 0295/1485] wpa_host DeathRecipient bugfix Signed-off-by: xiaosi --- .../hdi_service/service_common/wpa_common_cmd.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 093a97e172..7c8a188d3c 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -39,6 +39,7 @@ #include "hdi_wpa_common.h" #define BUF_SIZE 512 +#define MAX_WPA_WAIT_TIMES 30 pthread_t g_tid; const int QUOTATION_MARKS_FLAG_YES = 0; @@ -1058,6 +1059,8 @@ static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct } ReleaseWpaGlobalInterface(); HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); + ReleaseWifiStaInterface(0); + HDF_LOGI("%{public}s: call ReleaseWifiStaInterface finish", __func__); } static struct RemoteServiceDeathRecipient g_deathRecipient = { @@ -1957,17 +1960,27 @@ static void *WpaThreadMain(void *p) } int ret = wpa_main(param.argc, tmpArgv); HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret); + g_tid = 0; return NULL; } static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) { int32_t ret; + int32_t times = 0; if (moduleName == NULL || startCmd == NULL) { HDF_LOGE("%{public}s input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM ; } + while (g_tid != 0) { + HDF_LOGE("%{public}s: wpa_supplicant is already running!", __func__); + usleep(WPA_SLEEP_TIME); + times++; + if (times > MAX_WPA_WAIT_TIMES) { + return HDF_FAILURE; + } + } ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret); -- Gitee From 90d761289bb2c3be2655b4d9d71267b7dd074bae Mon Sep 17 00:00:00 2001 From: shilong Date: Thu, 22 Aug 2024 07:38:07 +0000 Subject: [PATCH 0296/1485] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/include/input_device_manager.h | 1 + input/udriver/src/input_device_manager.cpp | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/input/udriver/include/input_device_manager.h b/input/udriver/include/input_device_manager.h index 53bb54c50f..3290ed4b68 100644 --- a/input/udriver/include/input_device_manager.h +++ b/input/udriver/include/input_device_manager.h @@ -136,6 +136,7 @@ private: int32_t &epollFd, int32_t &fd, string devPath, std::shared_ptr &detailInfo); mutable std::mutex lock_; + std::mutex reportEventPkgCallBackLock_; std::map inputDevList_; struct epoll_event epollEventList_[EPOLL_MAX_EVENTS] {}; std::string devPath_ {"/dev/input"}; diff --git a/input/udriver/src/input_device_manager.cpp b/input/udriver/src/input_device_manager.cpp index 515a228ab8..c812938d0f 100644 --- a/input/udriver/src/input_device_manager.cpp +++ b/input/udriver/src/input_device_manager.cpp @@ -44,7 +44,9 @@ constexpr uint32_t DEV_INDEX_MAX = 32; void InputDeviceManager::Init() { inputDevList_.clear(); + reportEventPkgCallBackLock_.lock(); reportEventPkgCallback_.clear(); + reportEventPkgCallBackLock_.unlock(); GetInputDeviceInfoList(); std::thread t1([this] {this->WorkerThread();}); std::string wholeName1 = std::to_string(getpid()) + "_" + std::to_string(gettid()); @@ -100,6 +102,7 @@ void InputDeviceManager::ReportEventPkg(int32_t iFd, InputEventPackage **iEvtPkg HDF_LOGE("%{public}s: param invalid, line: %{public}d", __func__, __LINE__); return; } + std::lock_guard guard(reportEventPkgCallBackLock_); for (auto &callbackFunc : reportEventPkgCallback_) { uint32_t index {0}; auto ret = FindIndexFromFd(iFd, &index); @@ -824,6 +827,7 @@ RetStatus InputDeviceManager::RegisterReportCallback(uint32_t devIndex, InputEve HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } + std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = callback; return rc; } @@ -836,6 +840,7 @@ RetStatus InputDeviceManager::UnregisterReportCallback(uint32_t devIndex) HDF_LOGE("%{public}s: param is wrong", __func__); return INPUT_FAILURE; } + std::lock_guard guard(reportEventPkgCallBackLock_); reportEventPkgCallback_[devIndex] = nullptr; return rc; } -- Gitee From b55e76ccc72ceae1068f14b7e1ce2ec033a46694 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 08:22:16 +0000 Subject: [PATCH 0297/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd_ext.c | 1545 ++++++++++++++++- 1 file changed, 1493 insertions(+), 52 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index 439e14e513..94b2c343bd 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -31,20 +31,13 @@ #include "common/defs.h" #include "v1_1/iwpa_callback.h" #include "v1_1/iwpa_interface.h" -#include "wpa_client.h" + #include #include #include #include #include "hdi_wpa_common.h" -extern pthread_mutex_t g_interfaceLock; - -pthread_mutex_t *GetInterfaceLock() -{ - return &g_interfaceLock; -} - int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) { if (src == NULL || dst == NULL || dstLen == NULL) { @@ -73,6 +66,436 @@ struct HdfWpaStubData *HdfWpaStubDriver(void) return ®isterManager; } +int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +{ + int32_t ret = HDF_SUCCESS; + + if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { + HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); + if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, + tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, + (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, + (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill flags fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWifiWpaNetworkInfo->bssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->bssid); + hdiWifiWpaNetworkInfo->bssid = NULL; + } + if (hdiWifiWpaNetworkInfo->ssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->ssid); + hdiWifiWpaNetworkInfo->ssid = NULL; + } + if (hdiWifiWpaNetworkInfo->flags != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->flags); + hdiWifiWpaNetworkInfo->flags = NULL; + } + } + return ret; +} + +void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) +{ + if (halStatus == NULL) { + HDF_LOGE("%{public}s halStatus is NULL", __func__); + return; + } + status->id = halStatus->id; + status->freq = halStatus->freq; + if (strcmp(halStatus->keyMgmt, "") != 0) { + HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); + status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); + if (status->keyMgmt == NULL) { + HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); + status->keyMgmtLen = 0; + return; + } + status->keyMgmtLen = strlen(halStatus->keyMgmt); + if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } + if (strcmp(halStatus->ssid, "") != 0) { + HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); + status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); + if (status->ssid == NULL) { + HDF_LOGE("%{public}s status->ssid is NULL", __func__); + status->ssidLen = 0; + return; + } + status->ssidLen = strlen(halStatus->ssid); + if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } + if (strcmp(halStatus->address, "") != 0) { + HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); + uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->address, tmpAddress); + status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->address == NULL) { + HDF_LOGE("%{public}s status->address is NULL", __func__); + status->addressLen = 0; + return; + } + status->addressLen = ETH_ADDR_LEN + 1 ; + if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { + HDF_LOGE("%{public}s strcpy memcpy", __func__); + } + } + if (strcmp(halStatus->bssid, "") != 0) { + HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); + uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->bssid, tmpBssid); + status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->bssid == NULL) { + HDF_LOGE("%{public}s status->bssid is NULL", __func__); + status->bssidLen = 0; + return; + } + status->bssidLen = ETH_ADDR_LEN + 1 ; + if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } + } +} + +const char *macToStr(const u8 *addr) +{ + const int macAddrIndexOne = 0; + const int macAddrIndexTwo = 1; + const int macAddrIndexThree = 2; + const int macAddrIndexFour = 3; + const int macAddrIndexFive = 4; + const int macAddrIndexSix = 5; + static char macToStr[WIFI_BSSID_LENGTH]; + if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", + addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], + addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { + return NULL; + } + return macToStr; +} + +void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) +{ + HDF_LOGI("enter %{public}s ", __func__); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); + return; + } + int ret = pWpaInterface->wpaCliTerminate(); + if (ret != 0) { + HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); + } else { + HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); + } + ReleaseWpaGlobalInterface(); + HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); +} + +// void AddDeathRecipientForService(struct IWpaCallback *cbFunc) +// { +// HDF_LOGI("enter %{public}s ", __func__); +// if (cbFunc == NULL) { +// HDF_LOGE("invalid parameter"); +// return; +// } +// struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); +// if (remote == NULL) { +// HDF_LOGE("remote is NULL"); +// return; +// } +// HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); +// } + +int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + if (self == NULL) { + HDF_LOGE("%{public}s:self == NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!DListIsEmpty(head)) { + DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { + if (pos->service == self->AsObject(self)) { + HDF_LOGE("%{public}s: pos->service == self", __func__); + return HDF_FAILURE; + } + } + } + struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); + if (newRemoteNode == NULL) { + HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); + return HDF_FAILURE; + } + newRemoteNode->callbackObj = self; + newRemoteNode->service = self->AsObject(self); + DListInsertTail(&newRemoteNode->node, head); + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + AddDeathRecipientForService(self); + } + return HDF_SUCCESS; +} + +void HdfWpaDelRemoteObj(struct IWpaCallback *self) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct HdfWpaRemoteNode *tmp = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { + if (pos->service->index == self->AsObject(self)->index) { + DListRemove(&(pos->node)); + IWpaCallbackRelease(pos->callbackObj); + OsalMemFree(pos); + pos = NULL; + break; + } + } + IWpaCallbackRelease(self); +} + +int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { + HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; + hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; + if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, + disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaDisconnectParam->bssid != NULL) { + OsalMemFree(hdiWpaDisconnectParam->bssid); + hdiWpaDisconnectParam->bssid = NULL; + } + } + return ret; +} + +int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, + struct HdiWpaConnectParam *hdiWpaConnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (connectParam == NULL || hdiWpaConnectParam == NULL) { + HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaConnectParam->networkId = connectParam->networkId; + if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, + connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaConnectParam->bssid != NULL) { + OsalMemFree(hdiWpaConnectParam->bssid); + hdiWpaConnectParam->bssid = NULL; + } + } + return ret; +} + +int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) +{ + int32_t ret = HDF_SUCCESS; + + if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { + HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, + bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, + bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill reason fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaBssidChangedParam->bssid != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->bssid); + hdiWpaBssidChangedParam->bssid = NULL; + } + if (hdiWpaBssidChangedParam->reason != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->reason); + hdiWpaBssidChangedParam->reason = NULL; + } + } + return ret; +} + +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "wpa_common_cmd.h" +#include "wpa_p2p_cmd.h" +#include "hdi_wpa_hal.h" +#include +#include +#include +#include +#include +#include +#include "utils/common.h" +#include "wpa_supplicant_i.h" +#include "ctrl_iface.h" +#include "main.h" +#include "wps_supplicant.h" +#include "bssid_ignore.h" +#include "wpa_supplicant/config.h" +#include "common/defs.h" +#include "v1_1/iwpa_callback.h" +#include "v1_1/iwpa_interface.h" +// #include "wpa_client.h" +#include +#include +#include +#include +#include "hdi_wpa_common.h" + +#define BUF_SIZE 512 + +pthread_t g_tid; +const int QUOTATION_MARKS_FLAG_YES = 0; +const int QUOTATION_MARKS_FLAG_NO = 1; +const int MAX_NETWORKS_NUM = 100; +pthread_mutex_t g_interfaceLock = PTHREAD_MUTEX_INITIALIZER; + +static WpaSsidField g_wpaSsidFields[] = { + {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_PSK, "psk", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_KEYMGMT, "key_mgmt", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_PRIORITY, "priority", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_SCAN_SSID, "scan_ssid", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_EAP, "eap", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_IDENTITY, "identity", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_PASSWORD, "password", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_BSSID, "bssid", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_AUTH_ALGORITHMS, "auth_alg", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_IDX, "wep_tx_keyidx", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_0, "wep_key0", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_1, "wep_key1", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_2, "wep_key2", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WEP_KEY_3, "wep_key3", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_EAP_CLIENT_CERT, "client_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_EAP_PRIVATE_KEY, "private_key", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_EAP_PHASE2METHOD, "phase2", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_IEEE80211W, "ieee80211w", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_ALLOW_PROTOCOLS, "proto", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_GROUP_CIPHERS, "group", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_PAIRWISE_CIPHERS, "pairwise", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_SAE_PASSWD, "sae_password", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_CA_CERT, "wapi_ca_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_USER_CERT, "wapi_user_sel_cert", QUOTATION_MARKS_FLAG_YES}, + {DEVICE_CONFIG_WAPI_PSK_KEY_TYPE, "psk_key_type", QUOTATION_MARKS_FLAG_NO}, + {DEVICE_CONFIG_WAPI_PSK, "wapi_psk", QUOTATION_MARKS_FLAG_YES}, +}; + +int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH]) +{ + int flag = g_wpaSsidFields[pos].flag; + const int hexPskMaxLen = 64; + int len = strlen(value); + /* if the psk length is 64, it's hex format and don't need quotation marks */ + if (pos == DEVICE_CONFIG_PSK && len >= hexPskMaxLen) { + flag = QUOTATION_MARKS_FLAG_NO; + } + if (pos == DEVICE_CONFIG_WEP_KEY_0 || + pos == DEVICE_CONFIG_WEP_KEY_1 || + pos == DEVICE_CONFIG_WEP_KEY_2 || + pos == DEVICE_CONFIG_WEP_KEY_3) { + const int wepKeyLen1 = 5; + const int wepKeyLen2 = 13; + const int wepKeyLen3 = 16; + /* For wep key, ASCII format need quotation marks, hex format is not required */ + if (len == wepKeyLen1 || len == wepKeyLen2 || len == wepKeyLen3) { + flag = QUOTATION_MARKS_FLAG_YES; + } + } + return flag; +} + +pthread_mutex_t *GetInterfaceLock() +{ + return &g_interfaceLock; +} + +// int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) +// { +// if (src == NULL || dst == NULL || dstLen == NULL) { +// HDF_LOGE("%{public}s: Invalid parameter!", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); +// if (srcLen > 0) { +// *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); +// if (*dst == NULL) { +// HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); +// return HDF_FAILURE; +// } +// if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { +// HDF_LOGE("%{public}s: memcpy_s fail!", __func__); +// return HDF_FAILURE; +// } +// } +// *dstLen = srcLen; +// return HDF_SUCCESS; +// } + +// struct HdfWpaStubData *HdfWpaStubDriver(void) +// { +// static struct HdfWpaStubData registerManager; +// return ®isterManager; +// } + int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) { (void)self; @@ -106,7 +529,7 @@ int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) HDF_LOGI("%{public}s: StartScan successfully!", __func__); return HDF_SUCCESS; } - + int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, uint32_t *resultBufLen) { @@ -133,7 +556,7 @@ int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, u HDF_LOGI("%{public}s: Get scan result successfully!", __func__); return HDF_SUCCESS; } - + int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) { (void)self; @@ -160,7 +583,7 @@ int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, i HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); return HDF_SUCCESS; } - + int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) { (void)self; @@ -186,7 +609,7 @@ int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } - + int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) { (void)self; @@ -212,49 +635,1067 @@ int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifNam HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); return HDF_SUCCESS; } - -int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) + +int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId, const char *name, const char *value) { - int32_t ret = HDF_SUCCESS; - - if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { - HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + (void)self; + if (ifName == NULL || name == NULL || value == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - do { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); - if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, - tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (name != NULL) { + HDF_LOGI("%{public}s name = %{private}s", __func__, name); + } + if (value != NULL) { + HDF_LOGI("%{public}s value = %{private}s", __func__, value); + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaSetNetworkArgv conf; + if (memset_s(&conf, sizeof(conf), 0, sizeof(conf)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: memset_s conf fail", __func__); + return HDF_FAILURE; + } + conf.id = networkId; + int pos = -1; + for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { + if (strcmp(g_wpaSsidFields[i].fieldName, name) == 0) { + pos = i; + conf.param = g_wpaSsidFields[i].field; break; } - if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, - (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, - (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill flags fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWifiWpaNetworkInfo->bssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->bssid); - hdiWifiWpaNetworkInfo->bssid = NULL; - } - if (hdiWifiWpaNetworkInfo->ssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->ssid); - hdiWifiWpaNetworkInfo->ssid = NULL; - } - if (hdiWifiWpaNetworkInfo->flags != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->flags); - hdiWifiWpaNetworkInfo->flags = NULL; - } } - return ret; -} \ No newline at end of file + if (pos < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s SetNetwork: unsupported name %{public}s", __func__, name); + return HDF_FAILURE; + } + if (strncpy_s(conf.value, sizeof(conf.value), value, strlen(value)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s strncpy_s conf.value fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetNetwork(pStaIfc, &conf); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSetNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSetNetwork sucess ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +// static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, +// struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +// { +// int32_t ret = HDF_SUCCESS; + +// if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { +// HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// do { +// uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; +// hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); +// if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, +// tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill bssid fail!", __func__); +// ret = HDF_FAILURE; +// break; +// } +// if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, +// (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill ssid fail!", __func__); +// ret = HDF_FAILURE; +// } +// if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, +// (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill flags fail!", __func__); +// ret = HDF_FAILURE; +// } +// } while (0); +// if (ret != HDF_SUCCESS) { +// if (hdiWifiWpaNetworkInfo->bssid != NULL) { +// OsalMemFree(hdiWifiWpaNetworkInfo->bssid); +// hdiWifiWpaNetworkInfo->bssid = NULL; +// } +// if (hdiWifiWpaNetworkInfo->ssid != NULL) { +// OsalMemFree(hdiWifiWpaNetworkInfo->ssid); +// hdiWifiWpaNetworkInfo->ssid = NULL; +// } +// if (hdiWifiWpaNetworkInfo->flags != NULL) { +// OsalMemFree(hdiWifiWpaNetworkInfo->flags); +// hdiWifiWpaNetworkInfo->flags = NULL; +// } +// } +// return ret; +// } + +//need to check +int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, + struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL || networkInfo == NULL || networkInfoLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + int size = MAX_NETWORKS_NUM; + WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(size, sizeof(WifiNetworkInfo)); + if (infos == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: info = NULL", __func__); + return HDF_FAILURE; + } + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + free(infos); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdListNetworks(pStaIfc, infos, &size); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdListNetworks fail! ret = %{public}d", __func__, ret); + free(infos); + return HDF_FAILURE; + } + WifiNetworkInfo *infosTmp = infos; + HDF_LOGI("%{public}s: wpaCliCmdListNetworks success size = %{public}d", __func__, size); + for (int i = 0; i < ((size > MAX_NETWORKS_NUM) ? MAX_NETWORKS_NUM : size); i++) { + WpaFillWpaListNetworkParam(infos, networkInfo); + infos++; + networkInfo++; + } + *networkInfoLen = size; + free(infosTmp); + pthread_mutex_unlock(&g_interfaceLock); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSelectNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSelectNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSelectNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdEnableNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdEnableNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdEnableNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdReconnect(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdReconnect fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdReconnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdDisconnect(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdDisconnect fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdDisconnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, const int32_t enable) +{ + (void)self; + HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdPowerSave(pStaIfc, enable); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdPowerSave fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdPowerSave success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) +{ + (void)self; + HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetAutoConnect(pStaIfc, enable); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSetAutoConnect fail! ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSetAutoConnect success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +// static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) +// { +// if (halStatus == NULL) { +// HDF_LOGE("%{public}s halStatus is NULL", __func__); +// return; +// } +// status->id = halStatus->id; +// status->freq = halStatus->freq; +// if (strcmp(halStatus->keyMgmt, "") != 0) { +// HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); +// status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); +// if (status->keyMgmt == NULL) { +// HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); +// status->keyMgmtLen = 0; +// return; +// } +// status->keyMgmtLen = strlen(halStatus->keyMgmt); +// if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { +// HDF_LOGE("%{public}s strcpy failed", __func__); +// } +// } +// if (strcmp(halStatus->ssid, "") != 0) { +// HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); +// status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); +// if (status->ssid == NULL) { +// HDF_LOGE("%{public}s status->ssid is NULL", __func__); +// status->ssidLen = 0; +// return; +// } +// status->ssidLen = strlen(halStatus->ssid); +// if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { +// HDF_LOGE("%{public}s strcpy failed", __func__); +// } +// } +// if (strcmp(halStatus->address, "") != 0) { +// HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); +// uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; +// hwaddr_aton(halStatus->address, tmpAddress); +// status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); +// if (status->address == NULL) { +// HDF_LOGE("%{public}s status->address is NULL", __func__); +// status->addressLen = 0; +// return; +// } +// status->addressLen = ETH_ADDR_LEN + 1 ; +// if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { +// HDF_LOGE("%{public}s strcpy memcpy", __func__); +// } +// } +// if (strcmp(halStatus->bssid, "") != 0) { +// HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); +// uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; +// hwaddr_aton(halStatus->bssid, tmpBssid); +// status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); +// if (status->bssid == NULL) { +// HDF_LOGE("%{public}s status->bssid is NULL", __func__); +// status->bssidLen = 0; +// return; +// } +// status->bssidLen = ETH_ADDR_LEN + 1 ; +// if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { +// HDF_LOGE("%{public}s strcpy failed", __func__); +// } +// } +// } + +int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) +{ + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL || status == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaHalCmdStatus halStatus; + if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { + pthread_mutex_unlock(&g_interfaceLock); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + status->bssidLen = 0; + status->ssidLen = 0; + status->keyMgmtLen = 0; + status->addressLen = 0; + WpaProcessWifiStatus(&halStatus, status); + if (status->addressLen == 0) { + HDF_LOGE("%{public}s key not include address", __func__); + } + if (status->bssidLen == 0) { + HDF_LOGE("%{public}s key not include bssid", __func__); + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s ", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +// const char *macToStr(const u8 *addr) +// { +// const int macAddrIndexOne = 0; +// const int macAddrIndexTwo = 1; +// const int macAddrIndexThree = 2; +// const int macAddrIndexFour = 3; +// const int macAddrIndexFive = 4; +// const int macAddrIndexSix = 5; +// static char macToStr[WIFI_BSSID_LENGTH]; +// if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", +// addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], +// addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { +// return NULL; +// } +// return macToStr; +// } + +int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret; + if (wpaParam->anyFlag < 0 && wpaParam->multiAp <= 0 && wpaParam->bssidLen == 0) { + ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, NULL); + } else { + struct WpaWpsPbcArgv config = {0}; + config.anyFlag = wpaParam->anyFlag; + config.multiAp = wpaParam->multiAp; + if (wpaParam->bssidLen > 0) { + if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, + wpaParam->bssidLen) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); + return HDF_FAILURE; + } + } + ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); + } + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } else if (ret == WIFI_HAL_PBC_OVERLAP) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, + const struct HdiWifiWpsParam *wpaParam, int *pinCode) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL + || wpaParam->pinCode == NULL || pinCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaWpsPinArgv config = {{0}, {0}}; + if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), + strlen(macToStr(wpaParam->bssid))) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + + int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +//need to deal countryCodeLen +int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName, + char *countryCode, uint32_t countryCodeLen) +{ + HDF_LOGI("enter %{public}s: ", __func__); + (void)self; + if (ifName == NULL || countryCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +//need to deal valueLen +int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, + const int32_t networkId, const char *param, char *value, uint32_t valueLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || param == NULL || value == NULL || valueLen == 0) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + struct WpaGetNetworkArgv getNetwork = {0}; + getNetwork.id = networkId; + if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: strncpy_s param fail", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode) +{ + HDF_LOGI("enter %{public}s: mode = %{public}d", __func__, mode); + (void)self; + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName, + struct ConnectionCapabilities *connectionCap) +{ + HDF_LOGI("enter %{public}s: ", __func__); + (void)self; + if (ifName == NULL || connectionCap == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || enable == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int scanSsid = 0; + int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + *enable = (scanSsid == 1); + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName, + char *psk, uint32_t pskLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || psk == NULL || pskLen == 0) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || psk == NULL || pskLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx, + uint8_t *wepKey, uint32_t *wepKeyLen) +{ + HDF_LOGI("enter %{public}s keyIdx = %{public}d", __func__, keyIdx); + (void)self; + if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || keyIdx == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || enable == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); + if (ret != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode) +{ + HDF_LOGI("enter %{public}s ", __func__); + (void)self; + if (ifName == NULL || countryCode == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +// static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) +// { +// HDF_LOGI("enter %{public}s ", __func__); +// WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); +// if (pWpaInterface == NULL) { +// HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); +// return; +// } +// int ret = pWpaInterface->wpaCliTerminate(); +// if (ret != 0) { +// HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); +// } else { +// HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); +// } +// ReleaseWpaGlobalInterface(); +// HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); +// } + +static struct RemoteServiceDeathRecipient g_deathRecipient = { + .recipient = { + .OnRemoteDied = OnRemoteServiceDied, + } +}; + +void AddDeathRecipientForService(struct IWpaCallback *cbFunc) +{ + HDF_LOGI("enter %{public}s ", __func__); + if (cbFunc == NULL) { + HDF_LOGE("invalid parameter"); + return; + } + struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); + if (remote == NULL) { + HDF_LOGE("remote is NULL"); + return; + } + HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); +} + +// static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) +// { +// struct HdfWpaRemoteNode *pos = NULL; +// struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + +// if (self == NULL) { +// HDF_LOGE("%{public}s:self == NULL", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// if (!DListIsEmpty(head)) { +// DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { +// if (pos->service == self->AsObject(self)) { +// HDF_LOGE("%{public}s: pos->service == self", __func__); +// return HDF_FAILURE; +// } +// } +// } +// struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); +// if (newRemoteNode == NULL) { +// HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); +// return HDF_FAILURE; +// } +// newRemoteNode->callbackObj = self; +// newRemoteNode->service = self->AsObject(self); +// DListInsertTail(&newRemoteNode->node, head); +// if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { +// AddDeathRecipientForService(self); +// } +// return HDF_SUCCESS; +// } + +// static void HdfWpaDelRemoteObj(struct IWpaCallback *self) +// { +// struct HdfWpaRemoteNode *pos = NULL; +// struct HdfWpaRemoteNode *tmp = NULL; +// struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + +// DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { +// if (pos->service->index == self->AsObject(self)->index) { +// DListRemove(&(pos->node)); +// IWpaCallbackRelease(pos->callbackObj); +// OsalMemFree(pos); +// pos = NULL; +// break; +// } +// } +// IWpaCallbackRelease(self); +// } + +// static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, +// struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) +// { +// int32_t ret = HDF_SUCCESS; + +// if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { +// HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; +// hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; +// if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, +// disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill bssid fail!", __func__); +// ret = HDF_FAILURE; +// } +// if (ret != HDF_SUCCESS) { +// if (hdiWpaDisconnectParam->bssid != NULL) { +// OsalMemFree(hdiWpaDisconnectParam->bssid); +// hdiWpaDisconnectParam->bssid = NULL; +// } +// } +// return ret; +// } + +// static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, +// struct HdiWpaConnectParam *hdiWpaConnectParam) +// { +// int32_t ret = HDF_SUCCESS; + +// if (connectParam == NULL || hdiWpaConnectParam == NULL) { +// HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// hdiWpaConnectParam->networkId = connectParam->networkId; +// if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, +// connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill bssid fail!", __func__); +// ret = HDF_FAILURE; +// } +// if (ret != HDF_SUCCESS) { +// if (hdiWpaConnectParam->bssid != NULL) { +// OsalMemFree(hdiWpaConnectParam->bssid); +// hdiWpaConnectParam->bssid = NULL; +// } +// } +// return ret; +// } + +// static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, +// struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) +// { +// int32_t ret = HDF_SUCCESS; + +// if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { +// HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); +// return HDF_ERR_INVALID_PARAM; +// } +// do { +// if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, +// bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill bssid fail!", __func__); +// ret = HDF_FAILURE; +// break; +// } +// if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, +// bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { +// HDF_LOGE("%{public}s: fill reason fail!", __func__); +// ret = HDF_FAILURE; +// } +// } while (0); +// if (ret != HDF_SUCCESS) { +// if (hdiWpaBssidChangedParam->bssid != NULL) { +// OsalMemFree(hdiWpaBssidChangedParam->bssid); +// hdiWpaBssidChangedParam->bssid = NULL; +// } +// if (hdiWpaBssidChangedParam->reason != NULL) { +// OsalMemFree(hdiWpaBssidChangedParam->reason); +// hdiWpaBssidChangedParam->reason = NULL; +// } +// } +// return ret; +// } \ No newline at end of file -- Gitee From 53e1b205521b3298786958deeecf9e423af27268 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 08:23:58 +0000 Subject: [PATCH 0298/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd.c | 370 ++--- .../service_common/wpa_common_cmd.h | 15 + .../service_common/wpa_common_cmd_ext.c | 1354 ----------------- 3 files changed, 146 insertions(+), 1593 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index e1f8dc2f04..5d3fdad6b6 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -31,7 +31,6 @@ #include "common/defs.h" #include "v1_1/iwpa_callback.h" #include "v1_1/iwpa_interface.h" -#include "wpa_client.h" #include #include #include @@ -100,6 +99,11 @@ int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_L return flag; } +pthread_mutex_t *GetInterfaceLock() +{ + return &g_interfaceLock; +} + int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) { (void)self; @@ -134,6 +138,112 @@ int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) return HDF_SUCCESS; } +int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, + uint32_t *resultBufLen) +{ + HDF_LOGI("enter %{public}s", __func__); + (void)self; + if (ifName == NULL || resultBuf == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: Get scan result successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL || networkId == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + *networkId = ret; + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) +{ + (void)self; + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(&g_interfaceLock); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); + if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); + return HDF_SUCCESS; +} + int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId, const char *name, const char *value) { @@ -142,14 +252,26 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - HDF_LOGI("enter %{public}s networkId = %{public}d name = %{private}s value = %{private}s", __func__, networkId, - name, value); + HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); + if (name != NULL) { + HDF_LOGI("%{public}s name = %{private}s", __func__, name); + } + if (value != NULL) { + HDF_LOGI("%{public}s value = %{private}s", __func__, value); + } + pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } - struct WpaSetNetworkArgv conf = {0}; + struct WpaSetNetworkArgv conf; + if (memset_s(&conf, sizeof(conf), 0, sizeof(conf)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); + HDF_LOGE("%{public}s: memset_s conf fail", __func__); + return HDF_FAILURE; + } conf.id = networkId; int pos = -1; for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { @@ -160,18 +282,22 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, } } if (pos < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s SetNetwork: unsupported name %{public}s", __func__, name); return HDF_FAILURE; } if (strncpy_s(conf.value, sizeof(conf.value), value, strlen(value)) != 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s strncpy_s conf.value fail", __func__); return HDF_FAILURE; } int ret = pStaIfc->wpaCliCmdSetNetwork(pStaIfc, &conf); if (ret < 0) { + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: wpaCliCmdSetNetwork fail! ret = %{public}d", __func__, ret); return HDF_FAILURE; } + pthread_mutex_unlock(&g_interfaceLock); HDF_LOGI("%{public}s: wpaCliCmdSetNetwork sucess ret = %{public}d", __func__, ret); return HDF_SUCCESS; } @@ -378,72 +504,6 @@ int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } -static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) -{ - if (halStatus == NULL) { - HDF_LOGE("%{public}s halStatus is NULL", __func__); - return; - } - status->id = halStatus->id; - status->freq = halStatus->freq; - if (strcmp(halStatus->keyMgmt, "") != 0) { - HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); - status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); - if (status->keyMgmt == NULL) { - HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); - status->keyMgmtLen = 0; - return; - } - status->keyMgmtLen = strlen(halStatus->keyMgmt); - if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->ssid, "") != 0) { - HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); - status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); - if (status->ssid == NULL) { - HDF_LOGE("%{public}s status->ssid is NULL", __func__); - status->ssidLen = 0; - return; - } - status->ssidLen = strlen(halStatus->ssid); - if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->address, "") != 0) { - HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); - uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->address, tmpAddress); - status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->address == NULL) { - HDF_LOGE("%{public}s status->address is NULL", __func__); - status->addressLen = 0; - return; - } - status->addressLen = ETH_ADDR_LEN + 1 ; - if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { - HDF_LOGE("%{public}s strcpy memcpy", __func__); - } - } - if (strcmp(halStatus->bssid, "") != 0) { - HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); - uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->bssid, tmpBssid); - status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->bssid == NULL) { - HDF_LOGE("%{public}s status->bssid is NULL", __func__); - status->bssidLen = 0; - return; - } - status->bssidLen = ETH_ADDR_LEN + 1 ; - if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } -} - int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) { HDF_LOGI("enter %{public}s", __func__); @@ -511,23 +571,6 @@ int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) return HDF_SUCCESS; } -const char *macToStr(const u8 *addr) -{ - const int macAddrIndexOne = 0; - const int macAddrIndexTwo = 1; - const int macAddrIndexThree = 2; - const int macAddrIndexFour = 3; - const int macAddrIndexFive = 4; - const int macAddrIndexSix = 5; - static char macToStr[WIFI_BSSID_LENGTH]; - if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", - addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], - addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { - return NULL; - } - return macToStr; -} - int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) { HDF_LOGI("enter %{public}s ", __func__); @@ -964,31 +1007,13 @@ int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifNam return HDF_SUCCESS; } -static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) -{ - HDF_LOGI("enter %{public}s ", __func__); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); - return; - } - int ret = pWpaInterface->wpaCliTerminate(); - if (ret != 0) { - HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); - } else { - HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); - } - ReleaseWpaGlobalInterface(); - HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); -} - static struct RemoteServiceDeathRecipient g_deathRecipient = { .recipient = { .OnRemoteDied = OnRemoteServiceDied, } }; -static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) +void AddDeathRecipientForService(struct IWpaCallback *cbFunc) { HDF_LOGI("enter %{public}s ", __func__); if (cbFunc == NULL) { @@ -1003,139 +1028,6 @@ static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); } -static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - if (self == NULL) { - HDF_LOGE("%{public}s:self == NULL", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (!DListIsEmpty(head)) { - DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { - if (pos->service == self->AsObject(self)) { - HDF_LOGE("%{public}s: pos->service == self", __func__); - return HDF_FAILURE; - } - } - } - struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); - if (newRemoteNode == NULL) { - HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); - return HDF_FAILURE; - } - newRemoteNode->callbackObj = self; - newRemoteNode->service = self->AsObject(self); - DListInsertTail(&newRemoteNode->node, head); - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - AddDeathRecipientForService(self); - } - return HDF_SUCCESS; -} - -static void HdfWpaDelRemoteObj(struct IWpaCallback *self) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct HdfWpaRemoteNode *tmp = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { - if (pos->service->index == self->AsObject(self)->index) { - DListRemove(&(pos->node)); - IWpaCallbackRelease(pos->callbackObj); - OsalMemFree(pos); - pos = NULL; - break; - } - } - IWpaCallbackRelease(self); -} - -static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { - HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; - hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; - if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, - disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaDisconnectParam->bssid != NULL) { - OsalMemFree(hdiWpaDisconnectParam->bssid); - hdiWpaDisconnectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, - struct HdiWpaConnectParam *hdiWpaConnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (connectParam == NULL || hdiWpaConnectParam == NULL) { - HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaConnectParam->networkId = connectParam->networkId; - if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, - connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaConnectParam->bssid != NULL) { - OsalMemFree(hdiWpaConnectParam->bssid); - hdiWpaConnectParam->bssid = NULL; - } - } - return ret; -} - -static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) -{ - int32_t ret = HDF_SUCCESS; - - if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { - HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, - bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, - bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill reason fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaBssidChangedParam->bssid != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->bssid); - hdiWpaBssidChangedParam->bssid = NULL; - } - if (hdiWpaBssidChangedParam->reason != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->reason); - hdiWpaBssidChangedParam->reason = NULL; - } - } - return ret; -} - static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam, struct HdiWpaStateChangedParam *hdiWpaStateChangedParam) { diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 0c58322dd4..79c9d7e3e8 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -20,6 +20,7 @@ #include #include "utils/common.h" #include "wpa_supplicant_hal.h" +#include "wpa_client.h" #define WIFI_SSID_LENGTH 132 #define WIFI_BSSID_LENGTH 18 @@ -108,6 +109,20 @@ int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifNam int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName); int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd); +int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo); +void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status); +void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote); +void AddDeathRecipientForService(struct IWpaCallback *cbFunc); +int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName); +void HdfWpaDelRemoteObj(struct IWpaCallback *self); +int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam); +int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, + struct HdiWpaConnectParam *hdiWpaConnectParam); +int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam); + int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen); pthread_mutex_t *GetInterfaceLock(); diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index 94b2c343bd..6b21f358ec 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -213,21 +213,6 @@ void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRem HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); } -// void AddDeathRecipientForService(struct IWpaCallback *cbFunc) -// { -// HDF_LOGI("enter %{public}s ", __func__); -// if (cbFunc == NULL) { -// HDF_LOGE("invalid parameter"); -// return; -// } -// struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); -// if (remote == NULL) { -// HDF_LOGE("remote is NULL"); -// return; -// } -// HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); -// } - int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) { struct HdfWpaRemoteNode *pos = NULL; @@ -360,1342 +345,3 @@ int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedPar } return ret; } - -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "wpa_common_cmd.h" -#include "wpa_p2p_cmd.h" -#include "hdi_wpa_hal.h" -#include -#include -#include -#include -#include -#include -#include "utils/common.h" -#include "wpa_supplicant_i.h" -#include "ctrl_iface.h" -#include "main.h" -#include "wps_supplicant.h" -#include "bssid_ignore.h" -#include "wpa_supplicant/config.h" -#include "common/defs.h" -#include "v1_1/iwpa_callback.h" -#include "v1_1/iwpa_interface.h" -// #include "wpa_client.h" -#include -#include -#include -#include -#include "hdi_wpa_common.h" - -#define BUF_SIZE 512 - -pthread_t g_tid; -const int QUOTATION_MARKS_FLAG_YES = 0; -const int QUOTATION_MARKS_FLAG_NO = 1; -const int MAX_NETWORKS_NUM = 100; -pthread_mutex_t g_interfaceLock = PTHREAD_MUTEX_INITIALIZER; - -static WpaSsidField g_wpaSsidFields[] = { - {DEVICE_CONFIG_SSID, "ssid", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_PSK, "psk", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_KEYMGMT, "key_mgmt", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_PRIORITY, "priority", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_SCAN_SSID, "scan_ssid", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_EAP, "eap", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_IDENTITY, "identity", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_PASSWORD, "password", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_BSSID, "bssid", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_AUTH_ALGORITHMS, "auth_alg", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_IDX, "wep_tx_keyidx", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_0, "wep_key0", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_1, "wep_key1", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_2, "wep_key2", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WEP_KEY_3, "wep_key3", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_EAP_CLIENT_CERT, "client_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_EAP_PRIVATE_KEY, "private_key", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_EAP_PHASE2METHOD, "phase2", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_IEEE80211W, "ieee80211w", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_ALLOW_PROTOCOLS, "proto", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_GROUP_CIPHERS, "group", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_PAIRWISE_CIPHERS, "pairwise", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_SAE_PASSWD, "sae_password", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_CA_CERT, "wapi_ca_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_USER_CERT, "wapi_user_sel_cert", QUOTATION_MARKS_FLAG_YES}, - {DEVICE_CONFIG_WAPI_PSK_KEY_TYPE, "psk_key_type", QUOTATION_MARKS_FLAG_NO}, - {DEVICE_CONFIG_WAPI_PSK, "wapi_psk", QUOTATION_MARKS_FLAG_YES}, -}; - -int CalcQuotationMarksFlag(int pos, const char value[WIFI_NETWORK_CONFIG_VALUE_LENGTH]) -{ - int flag = g_wpaSsidFields[pos].flag; - const int hexPskMaxLen = 64; - int len = strlen(value); - /* if the psk length is 64, it's hex format and don't need quotation marks */ - if (pos == DEVICE_CONFIG_PSK && len >= hexPskMaxLen) { - flag = QUOTATION_MARKS_FLAG_NO; - } - if (pos == DEVICE_CONFIG_WEP_KEY_0 || - pos == DEVICE_CONFIG_WEP_KEY_1 || - pos == DEVICE_CONFIG_WEP_KEY_2 || - pos == DEVICE_CONFIG_WEP_KEY_3) { - const int wepKeyLen1 = 5; - const int wepKeyLen2 = 13; - const int wepKeyLen3 = 16; - /* For wep key, ASCII format need quotation marks, hex format is not required */ - if (len == wepKeyLen1 || len == wepKeyLen2 || len == wepKeyLen3) { - flag = QUOTATION_MARKS_FLAG_YES; - } - } - return flag; -} - -pthread_mutex_t *GetInterfaceLock() -{ - return &g_interfaceLock; -} - -// int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) -// { -// if (src == NULL || dst == NULL || dstLen == NULL) { -// HDF_LOGE("%{public}s: Invalid parameter!", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); -// if (srcLen > 0) { -// *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); -// if (*dst == NULL) { -// HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); -// return HDF_FAILURE; -// } -// if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { -// HDF_LOGE("%{public}s: memcpy_s fail!", __func__); -// return HDF_FAILURE; -// } -// } -// *dstLen = srcLen; -// return HDF_SUCCESS; -// } - -// struct HdfWpaStubData *HdfWpaStubDriver(void) -// { -// static struct HdfWpaStubData registerManager; -// return ®isterManager; -// } - -int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - ScanSettings settings = {0}; - settings.scanStyle = SCAN_TYPE_LOW_SPAN; - int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - if (ret == WIFI_HAL_SCAN_BUSY) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan return scan busy", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: StartScan successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, - uint32_t *resultBufLen) -{ - HDF_LOGI("enter %{public}s", __func__); - (void)self; - if (ifName == NULL || resultBuf == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: Get scan result successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - if (ifName == NULL || networkId == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdAddNetworks(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceAddNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - *networkId = ret; - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: add network success networkId = %{public}d", __func__, *networkId); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdRemoveNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceRemoveNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: remove network success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdDisableNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaInterfaceDisableNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: WpaInterfaceDisableNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId, const char *name, const char *value) -{ - (void)self; - if (ifName == NULL || name == NULL || value == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (name != NULL) { - HDF_LOGI("%{public}s name = %{private}s", __func__, name); - } - if (value != NULL) { - HDF_LOGI("%{public}s value = %{private}s", __func__, value); - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaSetNetworkArgv conf; - if (memset_s(&conf, sizeof(conf), 0, sizeof(conf)) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: memset_s conf fail", __func__); - return HDF_FAILURE; - } - conf.id = networkId; - int pos = -1; - for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { - if (strcmp(g_wpaSsidFields[i].fieldName, name) == 0) { - pos = i; - conf.param = g_wpaSsidFields[i].field; - break; - } - } - if (pos < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s SetNetwork: unsupported name %{public}s", __func__, name); - return HDF_FAILURE; - } - if (strncpy_s(conf.value, sizeof(conf.value), value, strlen(value)) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s strncpy_s conf.value fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetNetwork(pStaIfc, &conf); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSetNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSetNetwork sucess ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -// static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, -// struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) -// { -// int32_t ret = HDF_SUCCESS; - -// if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { -// HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// do { -// uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; -// hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); -// if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, -// tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill bssid fail!", __func__); -// ret = HDF_FAILURE; -// break; -// } -// if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, -// (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill ssid fail!", __func__); -// ret = HDF_FAILURE; -// } -// if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, -// (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill flags fail!", __func__); -// ret = HDF_FAILURE; -// } -// } while (0); -// if (ret != HDF_SUCCESS) { -// if (hdiWifiWpaNetworkInfo->bssid != NULL) { -// OsalMemFree(hdiWifiWpaNetworkInfo->bssid); -// hdiWifiWpaNetworkInfo->bssid = NULL; -// } -// if (hdiWifiWpaNetworkInfo->ssid != NULL) { -// OsalMemFree(hdiWifiWpaNetworkInfo->ssid); -// hdiWifiWpaNetworkInfo->ssid = NULL; -// } -// if (hdiWifiWpaNetworkInfo->flags != NULL) { -// OsalMemFree(hdiWifiWpaNetworkInfo->flags); -// hdiWifiWpaNetworkInfo->flags = NULL; -// } -// } -// return ret; -// } - -//need to check -int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, - struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL || networkInfo == NULL || networkInfoLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - int size = MAX_NETWORKS_NUM; - WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(size, sizeof(WifiNetworkInfo)); - if (infos == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: info = NULL", __func__); - return HDF_FAILURE; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - free(infos); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdListNetworks(pStaIfc, infos, &size); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdListNetworks fail! ret = %{public}d", __func__, ret); - free(infos); - return HDF_FAILURE; - } - WifiNetworkInfo *infosTmp = infos; - HDF_LOGI("%{public}s: wpaCliCmdListNetworks success size = %{public}d", __func__, size); - for (int i = 0; i < ((size > MAX_NETWORKS_NUM) ? MAX_NETWORKS_NUM : size); i++) { - WpaFillWpaListNetworkParam(infos, networkInfo); - infos++; - networkInfo++; - } - *networkInfoLen = size; - free(infosTmp); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSelectNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSelectNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSelectNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSelectNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceEnableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId) -{ - (void)self; - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdEnableNetwork(pStaIfc, networkId); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdEnableNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdEnableNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceReconnect(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdReconnect(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdReconnect fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdReconnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceDisconnect(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdDisconnect(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdDisconnect fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdDisconnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, const int32_t enable) -{ - (void)self; - HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdPowerSave(pStaIfc, enable); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdPowerSave fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdPowerSave success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) -{ - (void)self; - HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetAutoConnect(pStaIfc, enable); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSetAutoConnect fail! ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSetAutoConnect success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -// static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) -// { -// if (halStatus == NULL) { -// HDF_LOGE("%{public}s halStatus is NULL", __func__); -// return; -// } -// status->id = halStatus->id; -// status->freq = halStatus->freq; -// if (strcmp(halStatus->keyMgmt, "") != 0) { -// HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); -// status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); -// if (status->keyMgmt == NULL) { -// HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); -// status->keyMgmtLen = 0; -// return; -// } -// status->keyMgmtLen = strlen(halStatus->keyMgmt); -// if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { -// HDF_LOGE("%{public}s strcpy failed", __func__); -// } -// } -// if (strcmp(halStatus->ssid, "") != 0) { -// HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); -// status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); -// if (status->ssid == NULL) { -// HDF_LOGE("%{public}s status->ssid is NULL", __func__); -// status->ssidLen = 0; -// return; -// } -// status->ssidLen = strlen(halStatus->ssid); -// if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { -// HDF_LOGE("%{public}s strcpy failed", __func__); -// } -// } -// if (strcmp(halStatus->address, "") != 0) { -// HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); -// uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; -// hwaddr_aton(halStatus->address, tmpAddress); -// status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); -// if (status->address == NULL) { -// HDF_LOGE("%{public}s status->address is NULL", __func__); -// status->addressLen = 0; -// return; -// } -// status->addressLen = ETH_ADDR_LEN + 1 ; -// if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { -// HDF_LOGE("%{public}s strcpy memcpy", __func__); -// } -// } -// if (strcmp(halStatus->bssid, "") != 0) { -// HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); -// uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; -// hwaddr_aton(halStatus->bssid, tmpBssid); -// status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); -// if (status->bssid == NULL) { -// HDF_LOGE("%{public}s status->bssid is NULL", __func__); -// status->bssidLen = 0; -// return; -// } -// status->bssidLen = ETH_ADDR_LEN + 1 ; -// if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { -// HDF_LOGE("%{public}s strcpy failed", __func__); -// } -// } -// } - -int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) -{ - HDF_LOGI("enter %{public}s", __func__); - if (ifName == NULL || status == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaHalCmdStatus halStatus; - if (memset_s(&halStatus, sizeof(halStatus), 0, sizeof(halStatus)) != EOK) { - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdStatus(pStaIfc, ifName, &halStatus); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdStatus fail! ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - status->bssidLen = 0; - status->ssidLen = 0; - status->keyMgmtLen = 0; - status->addressLen = 0; - WpaProcessWifiStatus(&halStatus, status); - if (status->addressLen == 0) { - HDF_LOGE("%{public}s key not include address", __func__); - } - if (status->bssidLen == 0) { - HDF_LOGE("%{public}s key not include bssid", __func__); - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: WpaInterfaceWifiStatus success ", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s ", __func__); - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSaveConfig(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSaveConfig fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSaveConfig success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -// const char *macToStr(const u8 *addr) -// { -// const int macAddrIndexOne = 0; -// const int macAddrIndexTwo = 1; -// const int macAddrIndexThree = 2; -// const int macAddrIndexFour = 3; -// const int macAddrIndexFive = 4; -// const int macAddrIndexSix = 5; -// static char macToStr[WIFI_BSSID_LENGTH]; -// if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", -// addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], -// addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { -// return NULL; -// } -// return macToStr; -// } - -int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret; - if (wpaParam->anyFlag < 0 && wpaParam->multiAp <= 0 && wpaParam->bssidLen == 0) { - ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, NULL); - } else { - struct WpaWpsPbcArgv config = {0}; - config.anyFlag = wpaParam->anyFlag; - config.multiAp = wpaParam->multiAp; - if (wpaParam->bssidLen > 0) { - if (strncpy_s(config.bssid, sizeof(config.bssid), (const char *)wpaParam->bssid, - wpaParam->bssidLen) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); - return HDF_FAILURE; - } - } - ret = pStaIfc->wpaCliCmdWpsPbc(pStaIfc, &config); - } - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } else if (ret == WIFI_HAL_PBC_OVERLAP) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPbc fail PBC_OVERLAP ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsPbc success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, - const struct HdiWifiWpsParam *wpaParam, int *pinCode) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || wpaParam == NULL || wpaParam->bssid == NULL - || wpaParam->pinCode == NULL || pinCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaWpsPinArgv config = {{0}, {0}}; - if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), - strlen(macToStr(wpaParam->bssid))) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpsPin(pStaIfc, &config, pinCode); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsPin fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsPin success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceWpsCancel(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - - int ret = pStaIfc->wpaCliCmdWpsCancel(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpsCancel fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpsCancel success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -//need to deal countryCodeLen -int32_t WpaInterfaceGetCountryCode(struct IWpaInterface *self, const char *ifName, - char *countryCode, uint32_t countryCodeLen) -{ - HDF_LOGI("enter %{public}s: ", __func__); - (void)self; - if (ifName == NULL || countryCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetCountryCode(pStaIfc, countryCode, countryCodeLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetCountryCode fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetCountryCode success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -//need to deal valueLen -int32_t WpaInterfaceGetNetwork(struct IWpaInterface *self, const char *ifName, - const int32_t networkId, const char *param, char *value, uint32_t valueLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || param == NULL || value == NULL || valueLen == 0) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - struct WpaGetNetworkArgv getNetwork = {0}; - getNetwork.id = networkId; - if (strncpy_s(getNetwork.param, sizeof(getNetwork.param), param, strlen(param)) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: strncpy_s param fail", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetNetwork(pStaIfc, &getNetwork, value, valueLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetNetwork fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetNetwork success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceBlocklistClear(struct IWpaInterface *self, const char *ifName) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpaBlockListClear(pStaIfc); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpaBlockListClear fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpaBlockListClear success ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetSuspendMode(struct IWpaInterface *self, const char *ifName, const int32_t mode) -{ - HDF_LOGI("enter %{public}s: mode = %{public}d", __func__, mode); - (void)self; - if (ifName == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWpaSetSuspendMode(pStaIfc, mode); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWpaSetSuspendMode failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWpaSetSuspendMode success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetConnectionCapabilities(struct IWpaInterface *self, const char *ifName, - struct ConnectionCapabilities *connectionCap) -{ - HDF_LOGI("enter %{public}s: ", __func__); - (void)self; - if (ifName == NULL || connectionCap == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetConnectionCapabilities(pStaIfc, connectionCap); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetConnectionCapabilities failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetConnectionCapabilities success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetScanSsid(struct IWpaInterface *self, const char *ifName, int32_t *enable) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || enable == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int scanSsid = 0; - int ret = pStaIfc->wpaCliCmdGetScanSsid(pStaIfc, &scanSsid); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetScanSsid failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - *enable = (scanSsid == 1); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetScanSsid success, scanSsid = %{public}d ", __func__, scanSsid); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetPskPassphrase(struct IWpaInterface *self, const char *ifName, - char *psk, uint32_t pskLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || psk == NULL || pskLen == 0) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetPskPassphrase(pStaIfc, psk, pskLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetPskPassphrase failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetPskPassphrase success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetPsk(struct IWpaInterface *self, const char *ifName, uint8_t *psk, uint32_t *pskLen) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || psk == NULL || pskLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetPsk(pStaIfc, psk, pskLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetPsk failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetPsk success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetWepKey(struct IWpaInterface *self, const char *ifName, int keyIdx, - uint8_t *wepKey, uint32_t *wepKeyLen) -{ - HDF_LOGI("enter %{public}s keyIdx = %{public}d", __func__, keyIdx); - (void)self; - if (ifName == NULL || wepKey == NULL || wepKeyLen == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWepKey(pStaIfc, keyIdx, wepKey, wepKeyLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWepKey failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWepKey success!,ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetWepTxKeyIdx(struct IWpaInterface *self, const char *ifName, int *keyIdx) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || keyIdx == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdWepKeyTxKeyIdx(pStaIfc, keyIdx); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdWepKeyTxKeyIdx failed!,ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdWepKeyTxKeyIdx success!,*keyIdx = %{public}d", __func__, *keyIdx); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceGetRequirePmf(struct IWpaInterface *self, const char *ifName, int *enable) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || enable == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdGetRequirePmf(pStaIfc, enable); - if (ret != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdGetRequirePmf failed!, ret=%{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdGetRequirePmf success, ret=%{public}d enable=%{public}d ", __func__, ret, *enable); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifName, const char *countryCode) -{ - HDF_LOGI("enter %{public}s ", __func__); - (void)self; - if (ifName == NULL || countryCode == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdSetCountryCode(pStaIfc, countryCode); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: wpaCliCmdSetCountryCode failed!, ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpaCliCmdSetCountryCode success, ret = %{public}d", __func__, ret); - return HDF_SUCCESS; -} - -// static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) -// { -// HDF_LOGI("enter %{public}s ", __func__); -// WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); -// if (pWpaInterface == NULL) { -// HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); -// return; -// } -// int ret = pWpaInterface->wpaCliTerminate(); -// if (ret != 0) { -// HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); -// } else { -// HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); -// } -// ReleaseWpaGlobalInterface(); -// HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); -// } - -static struct RemoteServiceDeathRecipient g_deathRecipient = { - .recipient = { - .OnRemoteDied = OnRemoteServiceDied, - } -}; - -void AddDeathRecipientForService(struct IWpaCallback *cbFunc) -{ - HDF_LOGI("enter %{public}s ", __func__); - if (cbFunc == NULL) { - HDF_LOGE("invalid parameter"); - return; - } - struct HdfRemoteService *remote = cbFunc->AsObject(cbFunc); - if (remote == NULL) { - HDF_LOGE("remote is NULL"); - return; - } - HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); -} - -// static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) -// { -// struct HdfWpaRemoteNode *pos = NULL; -// struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - -// if (self == NULL) { -// HDF_LOGE("%{public}s:self == NULL", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// if (!DListIsEmpty(head)) { -// DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { -// if (pos->service == self->AsObject(self)) { -// HDF_LOGE("%{public}s: pos->service == self", __func__); -// return HDF_FAILURE; -// } -// } -// } -// struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); -// if (newRemoteNode == NULL) { -// HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); -// return HDF_FAILURE; -// } -// newRemoteNode->callbackObj = self; -// newRemoteNode->service = self->AsObject(self); -// DListInsertTail(&newRemoteNode->node, head); -// if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { -// AddDeathRecipientForService(self); -// } -// return HDF_SUCCESS; -// } - -// static void HdfWpaDelRemoteObj(struct IWpaCallback *self) -// { -// struct HdfWpaRemoteNode *pos = NULL; -// struct HdfWpaRemoteNode *tmp = NULL; -// struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - -// DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { -// if (pos->service->index == self->AsObject(self)->index) { -// DListRemove(&(pos->node)); -// IWpaCallbackRelease(pos->callbackObj); -// OsalMemFree(pos); -// pos = NULL; -// break; -// } -// } -// IWpaCallbackRelease(self); -// } - -// static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, -// struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) -// { -// int32_t ret = HDF_SUCCESS; - -// if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { -// HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; -// hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; -// if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, -// disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill bssid fail!", __func__); -// ret = HDF_FAILURE; -// } -// if (ret != HDF_SUCCESS) { -// if (hdiWpaDisconnectParam->bssid != NULL) { -// OsalMemFree(hdiWpaDisconnectParam->bssid); -// hdiWpaDisconnectParam->bssid = NULL; -// } -// } -// return ret; -// } - -// static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, -// struct HdiWpaConnectParam *hdiWpaConnectParam) -// { -// int32_t ret = HDF_SUCCESS; - -// if (connectParam == NULL || hdiWpaConnectParam == NULL) { -// HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// hdiWpaConnectParam->networkId = connectParam->networkId; -// if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, -// connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill bssid fail!", __func__); -// ret = HDF_FAILURE; -// } -// if (ret != HDF_SUCCESS) { -// if (hdiWpaConnectParam->bssid != NULL) { -// OsalMemFree(hdiWpaConnectParam->bssid); -// hdiWpaConnectParam->bssid = NULL; -// } -// } -// return ret; -// } - -// static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, -// struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) -// { -// int32_t ret = HDF_SUCCESS; - -// if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { -// HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); -// return HDF_ERR_INVALID_PARAM; -// } -// do { -// if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, -// bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill bssid fail!", __func__); -// ret = HDF_FAILURE; -// break; -// } -// if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, -// bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { -// HDF_LOGE("%{public}s: fill reason fail!", __func__); -// ret = HDF_FAILURE; -// } -// } while (0); -// if (ret != HDF_SUCCESS) { -// if (hdiWpaBssidChangedParam->bssid != NULL) { -// OsalMemFree(hdiWpaBssidChangedParam->bssid); -// hdiWpaBssidChangedParam->bssid = NULL; -// } -// if (hdiWpaBssidChangedParam->reason != NULL) { -// OsalMemFree(hdiWpaBssidChangedParam->reason); -// hdiWpaBssidChangedParam->reason = NULL; -// } -// } -// return ret; -// } \ No newline at end of file -- Gitee From 902c5cb5f73e6e60f3049fb3380294012976d382 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 11:27:34 +0000 Subject: [PATCH 0299/1485] update wlan/chip/hdi_service/wifi_vendor_hal.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.h | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.h b/wlan/chip/hdi_service/wifi_vendor_hal.h index 108cee7a3b..51574e9516 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.h +++ b/wlan/chip/hdi_service/wifi_vendor_hal.h @@ -56,6 +56,7 @@ public: std::pair GetPowerMode(const std::string& ifaceName); WifiError SetPowerMode(const std::string& ifaceName, int mode); WifiError StartScan(const std::string& ifaceName, const ScanParams& params); + WifiError GetChipModes(bool isPrimary, std::vector& modes); WifiError StartPnoScan(const std::string& ifaceName, const PnoScanParams& pnoParams); WifiError StopPnoScan(const std::string& ifaceName); WifiError GetScanInfos(const std::string& ifaceName, -- Gitee From fc31f047457a0382c277a975f328919cbb680bc8 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 11:28:49 +0000 Subject: [PATCH 0300/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index f12900fc5a..fa3797107d 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -315,6 +315,11 @@ WifiError WifiVendorHal::SetPowerMode(const std::string& ifaceName, int mode) return globalFuncTable_.setPowerMode(ifaceName.c_str(), mode); } +WifiError WifiVendorHal::GetChipModes(bool isPrimary, std::vector& modes) +{ + return globalFuncTable_.GetChipModes(isPrimary, modes); +} + WifiError WifiVendorHal::EnablePowerMode(const std::string& ifaceName, int mode) { return globalFuncTable_.enablePowerMode(ifaceName.c_str(), mode); -- Gitee From 17abf2be784c3a164eff7cd283f1f8582a7cdf3c Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 11:29:40 +0000 Subject: [PATCH 0301/1485] update wlan/chip/hdi_service/wifi_hal.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_hal.h | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/chip/hdi_service/wifi_hal.h b/wlan/chip/hdi_service/wifi_hal.h index 19fb659928..70611df304 100644 --- a/wlan/chip/hdi_service/wifi_hal.h +++ b/wlan/chip/hdi_service/wifi_hal.h @@ -111,6 +111,7 @@ typedef struct { WifiError (*wifiSetCountryCode)(wifiInterfaceHandle handle, const char *); WifiError (*getPowerMode)(const char *, int *); WifiError (*setPowerMode)(const char *, int); + WifiError (*GetChipModes)(bool, std::vector& modes); WifiError (*wifiStartScan)(wifiInterfaceHandle handle, const OHOS::HDI::Wlan::Chip::V1_0::ScanParams& scanParam); WifiError (*wifiStartPnoScan)(wifiInterfaceHandle handle, -- Gitee From 5ec076a8781fef742f0a69e5f6290eaaf7d8039e Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 11:31:09 +0000 Subject: [PATCH 0302/1485] update wlan/chip/hdi_service/wifi_chip.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_chip.cpp b/wlan/chip/hdi_service/wifi_chip.cpp index 3a18c8eb02..c7e4974cb5 100644 --- a/wlan/chip/hdi_service/wifi_chip.cpp +++ b/wlan/chip/hdi_service/wifi_chip.cpp @@ -69,7 +69,7 @@ WifiChip::WifiChip( isValid_(true), currentModeId_(chip_mode_ids::K_INVALID), ifaceUtil_(ifaceUtil), - modes_(chipModes.lock()->GetChipModes(isPrimary)), + vendorHal_.lock()->GetChipModes(isPrimary, modes_), subsystemCallbackHandler_(handler) {} -- Gitee From 39ce95c958dd1d6d795f7875426f43bb82d41cdf Mon Sep 17 00:00:00 2001 From: fengyong Date: Wed, 21 Aug 2024 10:20:41 +0800 Subject: [PATCH 0303/1485] hdf nfc tdd Signed-off-by: fengyong Signed-off-by: fengyong --- nfc/test/unittest/BUILD.gn | 44 ++- nfc/test/unittest/mock/mock.cpp | 127 ++++++++ nfc/test/unittest/mock/mock.h | 56 ++++ .../nfc_impl_mock_test/nfc_impl_mock_test.cpp | 294 ++++++++++++++++++ .../unittest/nfc_impl_test/nfc_impl_test.cpp | 95 +++++- .../nfc_vendor_adaptions_test.cpp | 142 +++++++++ secure_element/test/unittest/BUILD.gn | 3 +- 7 files changed, 746 insertions(+), 15 deletions(-) create mode 100644 nfc/test/unittest/mock/mock.cpp create mode 100644 nfc/test/unittest/mock/mock.h create mode 100644 nfc/test/unittest/nfc_impl_mock_test/nfc_impl_mock_test.cpp create mode 100644 nfc/test/unittest/nfc_vendor_adaptions_test/nfc_vendor_adaptions_test.cpp diff --git a/nfc/test/unittest/BUILD.gn b/nfc/test/unittest/BUILD.gn index 6396715f2c..712a46924b 100644 --- a/nfc/test/unittest/BUILD.gn +++ b/nfc/test/unittest/BUILD.gn @@ -20,6 +20,7 @@ config("hdf_nfc_unit_test_config") { include_dirs = [ "$NFC_DIR/hdi_service", "$NFC_DIR/vendor_adaptor", + "$NFC_DIR/test/unittest/mock", ] cflags_cc = [ "-fexceptions" ] @@ -44,12 +45,45 @@ unit_test_external_deps = [ "ipc:ipc_single", ] -test_out_path = "hdf_nfc/service" +test_out_path = "drivers_peripheral_nfc/drivers_peripheral_nfc" ohos_unittest("nfc_impl_test") { module_out_path = test_out_path - sources = [ "nfc_impl_test/nfc_impl_test.cpp" ] + sources = [ + "$NFC_DIR/test/unittest/mock/mock.cpp", + "nfc_impl_test/nfc_impl_test.cpp", + ] + + configs = [ ":hdf_nfc_unit_test_config" ] + + deps = unit_test_deps + + external_deps = unit_test_external_deps + + part_name = "drivers_peripheral_nfc" + subsystem_name = "hdf" +} + +ohos_unittest("nfc_impl_mock_test") { + module_out_path = test_out_path + + sources = [ "nfc_impl_mock_test/nfc_impl_mock_test.cpp" ] + + configs = [ ":hdf_nfc_unit_test_config" ] + + deps = unit_test_deps + + external_deps = unit_test_external_deps + + part_name = "drivers_peripheral_nfc" + subsystem_name = "hdf" +} + +ohos_unittest("nfc_vendor_adaptions_test") { + module_out_path = test_out_path + + sources = [ "nfc_vendor_adaptions_test/nfc_vendor_adaptions_test.cpp" ] configs = [ ":hdf_nfc_unit_test_config" ] @@ -64,5 +98,9 @@ ohos_unittest("nfc_impl_test") { group("hdf_nfc_unittest") { testonly = true - deps = [ ":nfc_impl_test" ] + deps = [ + ":nfc_impl_mock_test", + ":nfc_impl_test", + ":nfc_vendor_adaptions_test", + ] } diff --git a/nfc/test/unittest/mock/mock.cpp b/nfc/test/unittest/mock/mock.cpp new file mode 100644 index 0000000000..5735f6b4dc --- /dev/null +++ b/nfc/test/unittest/mock/mock.cpp @@ -0,0 +1,127 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "mock.h" + +namespace OHOS { +namespace HDI { +namespace Nfc { +NfcVendorAdaptions::NfcVendorAdaptions() +{ + nfcHalHandle = nullptr; + nfcHalInf.nfcHalOpen = nullptr; + nfcHalInf.nfcHalWrite = nullptr; + nfcHalInf.nfcHalCoreInitialized = nullptr; + nfcHalInf.nfcHalPrediscover = nullptr; + nfcHalInf.nfcHalClose = nullptr; + nfcHalInf.nfcHalControlGranted = nullptr; + nfcHalInf.nfcHalPowerCycle = nullptr; + nfcHalInf.nfcHalIoctl = nullptr; + nfcHalInf.nfcHalGetConfig = nullptr; + nfcHalInf.nfcHalFactoryReset = nullptr; + nfcHalInf.nfcHalShutdownCase = nullptr; + nfcExtHandle = nullptr; + nfcExtInf.getNfcChipType = nullptr; + nfcExtInf.getNfcHalFuncNameSuffix = nullptr; +} + +NfcVendorAdaptions::~NfcVendorAdaptions() {} + +int NfcVendorAdaptions::VendorOpen(NfcStackCallbackT *pCback, NfcStackDataCallbackT *pDataCback) +{ + return 0; +} + +int NfcVendorAdaptions::VendorWrite(uint16_t dataLen, const uint8_t *pData) +{ + return 0; +} + +int NfcVendorAdaptions::VendorCoreInitialized(uint16_t coreInitRspLen, uint8_t *pCoreInitRspParams) +{ + return 0; +} + +int NfcVendorAdaptions::VendorPrediscover(void) +{ + return -1; +} + +int NfcVendorAdaptions::VendorClose(bool bShutdown) +{ + return 0; +} + +int NfcVendorAdaptions::VendorControlGranted(void) +{ + return -1; +} + +int NfcVendorAdaptions::VendorPowerCycle(void) +{ + return 0; +} + +int NfcVendorAdaptions::VendorIoctl(long arg, void *pData) +{ + return 0; +} + +int NfcVendorAdaptions::VendorIoctlWithResponse(long arg, void *pData, std::vector &pRetVal) +{ + return 0; +} + +int NfcVendorAdaptions::VendorGetConfig(V1_1::NfcVendorConfig &config) +{ + return -1; +} + +int NfcVendorAdaptions::VendorFactoryReset(void) +{ + return -1; +} + +int NfcVendorAdaptions::VendorShutdownCase(void) +{ + return 0; +} + +std::string NfcVendorAdaptions::GetChipType(void) +{ + return ""; +} + +std::string NfcVendorAdaptions::GetNfcHalFuncNameSuffix(const std::string &chipType) +{ + return ""; +} + +void NfcVendorAdaptions::ResetNfcInterface(void) +{ + return; +} + +int8_t NfcVendorAdaptions::InitNfcHalInterfaces(std::string nfcHalSoName, std::string suffix) +{ + return 0; +} + +void NfcVendorAdaptions::CheckFirmwareUpdate(void) +{ + return; +} +} // Nfc +} // HDI +} // OHOS \ No newline at end of file diff --git a/nfc/test/unittest/mock/mock.h b/nfc/test/unittest/mock/mock.h new file mode 100644 index 0000000000..1af732ea7e --- /dev/null +++ b/nfc/test/unittest/mock/mock.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MOCK_VENDOR_ADAPTIONS_H +#define MOCK_VENDOR_ADAPTIONS_H + +#include +#include "nfc_vendor_adaptions.h" + +namespace OHOS { +namespace HDI { +namespace Nfc { +class Mock : public NfcVendorAdaptions { +public: + int VendorOpen(NfcStackCallbackT *pCback, NfcStackDataCallbackT *pDataCback); + int VendorWrite(uint16_t dataLen, const uint8_t *pData); + int VendorCoreInitialized(uint16_t coreInitRspLen, uint8_t *pCoreInitRspParams); + int VendorPrediscover(void); + int VendorClose(bool bShutdown); + int VendorControlGranted(void); + int VendorPowerCycle(void); + int VendorIoctl(long arg, void *pData); + int VendorIoctlWithResponse(long arg, void *pData, std::vector &pRetVal); + int VendorGetConfig(V1_1::NfcVendorConfig &config); + int VendorFactoryReset(void); + int VendorShutdownCase(void); + +private: + std::string GetChipType(void); + std::string GetNfcHalFuncNameSuffix(const std::string &chipType); + void ResetNfcInterface(void); + int8_t InitNfcHalInterfaces(std::string nfcHalSoName, std::string suffix); + void CheckFirmwareUpdate(void); + + void *nfcHalHandle; // handle of nfc hal so + NfcHalInterface nfcHalInf; + + void *nfcExtHandle; // handle of nfc ext service + NfcExtInterface nfcExtInf; +}; +} // Nfc +} // HDI +} // OHOS + +#endif // MOCK_VENDOR_ADAPTIONS_H diff --git a/nfc/test/unittest/nfc_impl_mock_test/nfc_impl_mock_test.cpp b/nfc/test/unittest/nfc_impl_mock_test/nfc_impl_mock_test.cpp new file mode 100644 index 0000000000..54b44e4c6a --- /dev/null +++ b/nfc/test/unittest/nfc_impl_mock_test/nfc_impl_mock_test.cpp @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include + +#include "nfc_impl.h" + +namespace OHOS { +namespace HDI { +namespace Nfc { +namespace V1_1 { +namespace TEST { +using namespace testing; +using namespace testing::ext; +using namespace OHOS::HDI::Nfc; +class NfcImplTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void NfcImplTest::SetUpTestCase() +{ + HDF_LOGD("SetUpTestCase NfcImplTest"); +} + +void NfcImplTest::TearDownTestCase() +{ + HDF_LOGD("TearDownTestCase NfcImplTest"); +} + +void NfcImplTest::SetUp() +{ + HDF_LOGD("SetUp NfcImplTest"); +} + +void NfcImplTest::TearDown() +{ + HDF_LOGD("TearDown NfcImplTest"); +} + +/** + * @tc.name: Open001 + * @tc.desc: Test NfcImplTest Open. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Open001, TestSize.Level1) +{ + const sptr callbackObj = nullptr; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Open(callbackObj, status); + EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: CoreInitialized001 + * @tc.desc: Test NfcImplTest CoreInitialized. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, CoreInitialized001, TestSize.Level1) +{ + std::vector data; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->CoreInitialized(data, status); + EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: CoreInitialized002 + * @tc.desc: Test NfcImplTest CoreInitialized. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, CoreInitialized002, TestSize.Level1) +{ + std::vector data = {0x01, 0x02, 0x03}; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->CoreInitialized(data, status); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: Prediscover001 + * @tc.desc: Test NfcImplTest Prediscover. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Prediscover001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Prediscover(status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: Write001 + * @tc.desc: Test NfcImplTest Write. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Write001, TestSize.Level1) +{ + std::vector data; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Write(data, status); + ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: Write002 + * @tc.desc: Test NfcImplTest Write. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Write002, TestSize.Level1) +{ + std::vector data = {0x001, 0x002, 0x003}; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Write(data, status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: ControlGranted001 + * @tc.desc: Test NfcImplTest ControlGranted. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, ControlGranted001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->ControlGranted(status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: PowerCycle001 + * @tc.desc: Test NfcImplTest PowerCycle. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, PowerCycle001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->PowerCycle(status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: Close001 + * @tc.desc: Test NfcImplTest Close. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Close001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Close(status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: Ioctl001 + * @tc.desc: Test NfcImplTest Ioctl. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Ioctl001, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Ioctl(cmd, data, status); + ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: Ioctl002 + * @tc.desc: Test NfcImplTest Ioctl. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Ioctl002, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data = {0x01, 0x02, 0x03}; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Ioctl(cmd, data, status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: IoctlWithResponse001 + * @tc.desc: Test NfcImplTest IoctlWithResponse. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, IoctlWithResponse001, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data; + std::vector response; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->IoctlWithResponse(cmd, data, response, status); + ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: IoctlWithResponse002 + * @tc.desc: Test NfcImplTest IoctlWithResponse. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, IoctlWithResponse002, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data = {0X001}; + std::vector response; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->IoctlWithResponse(cmd, data, response, status); + ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: IoctlWithResponse003 + * @tc.desc: Test NfcImplTest IoctlWithResponse. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, IoctlWithResponse003, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133}; + std::vector response; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->IoctlWithResponse(cmd, data, response, status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: GetVendorConfig001 + * @tc.desc: Test NfcImplTest GetVendorConfig. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, GetVendorConfig001, TestSize.Level1) +{ + NfcVendorConfig config; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->GetVendorConfig(config, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: DoFactoryReset001 + * @tc.desc: Test NfcImplTest DoFactoryReset. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, DoFactoryReset001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->DoFactoryReset(status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} +} +} +} +} +} \ No newline at end of file diff --git a/nfc/test/unittest/nfc_impl_test/nfc_impl_test.cpp b/nfc/test/unittest/nfc_impl_test/nfc_impl_test.cpp index 25b2756a0b..216995a2e8 100644 --- a/nfc/test/unittest/nfc_impl_test/nfc_impl_test.cpp +++ b/nfc/test/unittest/nfc_impl_test/nfc_impl_test.cpp @@ -14,15 +14,19 @@ */ #include #include +#include #include "nfc_impl.h" +#include "mock.h" namespace OHOS { namespace HDI { namespace Nfc { namespace V1_1 { namespace TEST { +using namespace testing; using namespace testing::ext; +using namespace OHOS::HDI::Nfc; class NfcImplTest : public testing::Test { public: static void SetUpTestCase(); @@ -33,22 +37,22 @@ public: void NfcImplTest::SetUpTestCase() { - std::cout << " SetUpTestCase NfcImplTest." << std::endl; + HDF_LOGD("SetUpTestCase NfcImplTest"); } void NfcImplTest::TearDownTestCase() { - std::cout << " TearDownTestCase NfcImplTest." << std::endl; + HDF_LOGD("TearDownTestCase NfcImplTest"); } void NfcImplTest::SetUp() { - std::cout << " SetUp NfcImplTest." << std::endl; + HDF_LOGD("SetUp NfcImplTest"); } void NfcImplTest::TearDown() { - std::cout << " TearDown NfcImplTest." << std::endl; + HDF_LOGD("TearDown NfcImplTest"); } /** @@ -62,7 +66,7 @@ HWTEST_F(NfcImplTest, Open001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->Open(callbackObj, status); - ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); + EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); } /** @@ -76,7 +80,21 @@ HWTEST_F(NfcImplTest, CoreInitialized001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->CoreInitialized(data, status); - ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); + EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); +} + +/** + * @tc.name: CoreInitialized002 + * @tc.desc: Test NfcImplTest CoreInitialized. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, CoreInitialized002, TestSize.Level1) +{ + std::vector data = {0x01, 0x02, 0x03}; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->CoreInitialized(data, status); + EXPECT_EQ(ret, HDF_SUCCESS); } /** @@ -89,7 +107,7 @@ HWTEST_F(NfcImplTest, Prediscover001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->Prediscover(status); - ASSERT_TRUE(ret == HDF_SUCCESS); + ASSERT_TRUE(ret == HDF_FAILURE); } /** @@ -117,7 +135,7 @@ HWTEST_F(NfcImplTest, Write002, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->Write(data, status); - ASSERT_TRUE(ret == HDF_FAILURE); + ASSERT_TRUE(ret == HDF_SUCCESS); } /** @@ -130,7 +148,7 @@ HWTEST_F(NfcImplTest, ControlGranted001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->ControlGranted(status); - ASSERT_TRUE(ret == HDF_SUCCESS); + ASSERT_TRUE(ret == HDF_FAILURE); } /** @@ -143,7 +161,7 @@ HWTEST_F(NfcImplTest, PowerCycle001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->PowerCycle(status); - ASSERT_TRUE(ret == HDF_FAILURE); + ASSERT_TRUE(ret == HDF_SUCCESS); } /** @@ -156,7 +174,7 @@ HWTEST_F(NfcImplTest, Close001, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->Close(status); - ASSERT_TRUE(ret == HDF_FAILURE); + ASSERT_TRUE(ret == HDF_SUCCESS); } /** @@ -174,6 +192,21 @@ HWTEST_F(NfcImplTest, Ioctl001, TestSize.Level1) ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); } +/** + * @tc.name: Ioctl002 + * @tc.desc: Test NfcImplTest Ioctl. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Ioctl002, TestSize.Level1) +{ + NfcCommand cmd = NfcCommand::CMD_INVALID; + std::vector data = {0x01, 0x02, 0x03}; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Ioctl(cmd, data, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + /** * @tc.name: IoctlWithResponse001 * @tc.desc: Test NfcImplTest IoctlWithResponse. @@ -226,8 +259,48 @@ HWTEST_F(NfcImplTest, IoctlWithResponse003, TestSize.Level1) NfcStatus status = NfcStatus::OK; std::shared_ptr nfcImpl = std::make_shared(); int ret = nfcImpl->IoctlWithResponse(cmd, data, response, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: GetVendorConfig001 + * @tc.desc: Test NfcImplTest GetVendorConfig. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, GetVendorConfig001, TestSize.Level1) +{ + NfcVendorConfig config; + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->GetVendorConfig(config, status); + ASSERT_TRUE(ret == HDF_FAILURE); +} + +/** + * @tc.name: DoFactoryReset001 + * @tc.desc: Test NfcImplTest DoFactoryReset. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, DoFactoryReset001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->DoFactoryReset(status); ASSERT_TRUE(ret == HDF_FAILURE); } + +/** + * @tc.name: Shutdown001 + * @tc.desc: Test NfcImplTest Shutdown. + * @tc.type: FUNC + */ +HWTEST_F(NfcImplTest, Shutdown001, TestSize.Level1) +{ + NfcStatus status = NfcStatus::OK; + std::shared_ptr nfcImpl = std::make_shared(); + int ret = nfcImpl->Shutdown(status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} } } } diff --git a/nfc/test/unittest/nfc_vendor_adaptions_test/nfc_vendor_adaptions_test.cpp b/nfc/test/unittest/nfc_vendor_adaptions_test/nfc_vendor_adaptions_test.cpp new file mode 100644 index 0000000000..7aab27dec9 --- /dev/null +++ b/nfc/test/unittest/nfc_vendor_adaptions_test/nfc_vendor_adaptions_test.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include + +#include "nfc_vendor_adaptions.h" +#include "nfc_impl.h" + +namespace OHOS { +namespace HDI { +namespace Nfc { +namespace TEST { +using namespace testing; +using namespace testing::ext; +using namespace OHOS::HDI::Nfc; +class NfcVendorAdaptionsTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void NfcVendorAdaptionsTest::SetUpTestCase() +{ + HDF_LOGD("SetUpTestCase NfcVendorAdaptionsTest"); +} + +void NfcVendorAdaptionsTest::TearDownTestCase() +{ + HDF_LOGD("TearDownTestCase NfcVendorAdaptionsTest"); +} + +void NfcVendorAdaptionsTest::SetUp() +{ + HDF_LOGD("SetUp NfcVendorAdaptionsTest"); +} + +void NfcVendorAdaptionsTest::TearDown() +{ + HDF_LOGD("TearDown NfcVendorAdaptionsTest"); +} + +/** + * @tc.name: VendorOpen001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorOpen. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorOpen001, TestSize.Level1) +{ + NfcStackCallbackT *pCback = nullptr; + NfcStackDataCallbackT *pDataCback = nullptr; + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorOpen(pCback, pDataCback); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: VendorCoreInitialized001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorCoreInitialized. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorCoreInitialized001, TestSize.Level1) +{ + uint16_t coreInitRspLen = 0; + uint8_t *pCoreInitRspParams = nullptr; + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorCoreInitialized(coreInitRspLen, pCoreInitRspParams); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: VendorWrite001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorWrite. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorWrite001, TestSize.Level1) +{ + uint16_t dataLen = 0; + uint8_t *pData = nullptr; + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorWrite(dataLen, pData); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: VendorIoctl001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorIoctl. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorIoctl001, TestSize.Level1) +{ + long arg = 0; + void *pData = nullptr; + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorIoctl(arg, pData); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: VendorIoctlWithResponse001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorIoctlWithResponse. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorIoctlWithResponse001, TestSize.Level1) +{ + long arg = 0; + void *pData = nullptr; + std::vector pRetVal; + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorIoctlWithResponse(arg, pData, pRetVal); + EXPECT_EQ(ret, HDF_FAILURE); +} + +/** + * @tc.name: VendorShutdownCase001 + * @tc.desc: Test NfcVendorAdaptionsTest VendorShutdownCase. + * @tc.type: FUNC + */ +HWTEST_F(NfcVendorAdaptionsTest, VendorShutdownCase001, TestSize.Level1) +{ + std::shared_ptr nfcVendorAdaptions = std::make_shared(); + int ret = nfcVendorAdaptions->VendorShutdownCase(); + EXPECT_EQ(ret, HDF_SUCCESS); +} +} +} +} +} \ No newline at end of file diff --git a/secure_element/test/unittest/BUILD.gn b/secure_element/test/unittest/BUILD.gn index c29f416710..568a0fcdd8 100644 --- a/secure_element/test/unittest/BUILD.gn +++ b/secure_element/test/unittest/BUILD.gn @@ -46,7 +46,8 @@ unit_test_external_deps = [ "ipc:ipc_single", ] -test_out_path = "hdf_se/service" +test_out_path = + "drivers_peripheral_secure_element/drivers_peripheral_secure_element" ohos_unittest("se_impl_test") { module_out_path = test_out_path -- Gitee From bef914f45afbaaaf84387ba40e5cddd9badc39ba Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 11:32:09 +0000 Subject: [PATCH 0304/1485] update wlan/chip/hdi_service/wifi_chip_modes.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip_modes.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_chip_modes.h b/wlan/chip/hdi_service/wifi_chip_modes.h index 0927006cee..ed0520225a 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.h +++ b/wlan/chip/hdi_service/wifi_chip_modes.h @@ -22,7 +22,7 @@ #define SUBCHIP_PROP "ohos.boot.odm.conn.schiptype" #define PROP_SUBCHIPTYPE_LEN 10 -#define SUPPORT_COEXCHIP "bisheng" +#define SUPPORT_COEXCHIP "" #define TRIPLE_MODE_PROP "vendor.hw_mc.wifi.triplemodes" #define SAPCOEXIST_PROP "hw_mc.wifi.support_sapcoexist" #define PROP_MAX_LEN 128 -- Gitee From b667a43a317311f0e32f43ea9a5d1fb64d492d7e Mon Sep 17 00:00:00 2001 From: xiaosi Date: Thu, 22 Aug 2024 20:00:46 +0800 Subject: [PATCH 0305/1485] wpa_host DeathRecipient bugfix Signed-off-by: xiaosi --- .../wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 7c8a188d3c..1a92106393 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -1974,10 +1974,11 @@ static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) return HDF_ERR_INVALID_PARAM ; } while (g_tid != 0) { - HDF_LOGE("%{public}s: wpa_supplicant is already running!", __func__); + HDF_LOGI("%{public}s: wpa_supplicant is already running!", __func__); usleep(WPA_SLEEP_TIME); times++; if (times > MAX_WPA_WAIT_TIMES) { + HDF_LOGE("%{public}s: wait supplicant time out!", __func__); return HDF_FAILURE; } } -- Gitee From 63a96f592a92cd2e199d94a79bab63f66e9385fc Mon Sep 17 00:00:00 2001 From: qinjihong Date: Thu, 22 Aug 2024 20:18:29 +0800 Subject: [PATCH 0306/1485] add tests for clearhalt and resetdevice Signed-off-by: qinjihong --- usb/ddk/host/src/linux_adapter.c | 6 +- usb/test/benchmarktest/BUILD.gn | 2 +- .../usb_benchmark_request_test.cpp | 57 +++++- usb/test/fuzztest/fuzztest.gni | 2 +- .../fuzztest/usbclearhalt_fuzzer/BUILD.gn | 55 ++++++ .../fuzztest/usbclearhalt_fuzzer/corpus/init | 14 ++ .../fuzztest/usbclearhalt_fuzzer/project.xml | 25 +++ .../usbclearhalt_fuzzer.cpp | 63 ++++++ .../usbclearhalt_fuzzer/usbclearhalt_fuzzer.h | 21 ++ .../fuzztest/usbresetdevice_fuzzer/BUILD.gn | 55 ++++++ .../usbresetdevice_fuzzer/corpus/init | 14 ++ .../usbresetdevice_fuzzer/project.xml | 25 +++ .../usbresetdevice_fuzzer.cpp | 63 ++++++ .../usbresetdevice_fuzzer.h | 21 ++ .../hal/src/usbd_device_status_test.cpp | 184 ++++++++++++++++++ .../unittest/hal/src/usbd_device_test.cpp | 103 +++++++++- 16 files changed, 699 insertions(+), 11 deletions(-) create mode 100644 usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn create mode 100644 usb/test/fuzztest/usbclearhalt_fuzzer/corpus/init create mode 100644 usb/test/fuzztest/usbclearhalt_fuzzer/project.xml create mode 100644 usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.cpp create mode 100644 usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.h create mode 100644 usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn create mode 100644 usb/test/fuzztest/usbresetdevice_fuzzer/corpus/init create mode 100644 usb/test/fuzztest/usbresetdevice_fuzzer/project.xml create mode 100644 usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.cpp create mode 100644 usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.h diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 245e497330..07cbe664a4 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -487,7 +487,7 @@ static int32_t OsSubmitBulkRequestHandleUrb( urb->buffer = request->buffer + (number * bulkBufferLen); if (number == request->numUrbs - 1) { uint32_t len = request->length % (uint32_t)(bulkBufferLen); - urb->bufferLength = (int32_t)(len == 0) ? bulkBufferLen : len; + urb->bufferLength = (int32_t)(len == 0) ? bulkBufferLen : (int32_t)len; } else { urb->bufferLength = bulkBufferLen; } @@ -551,7 +551,7 @@ static int32_t OsSubmitBulkRequest(struct UsbHostRequest *request) if (request->devHandle->caps & USB_ADAPTER_CAP_BULK_SCATTER_GATHER) { // The 1 is to prevent division by zero errors - bulkBufferLen = (int32_t)request->length ? request->length : 1; + bulkBufferLen = (int32_t)request->length ? (int32_t)request->length : 1; } else if (request->devHandle->caps & USB_ADAPTER_CAP_BULK_CONTINUATION) { bulkBufferLen = MAX_BULK_DATA_BUFFER_LENGTH; } else if (request->devHandle->caps & USB_ADAPTER_CAP_NO_PACKET_SIZE_LIM) { @@ -560,7 +560,7 @@ static int32_t OsSubmitBulkRequest(struct UsbHostRequest *request) } else { bulkBufferLen = MAX_BULK_DATA_BUFFER_LENGTH; } - numUrbs = request->length / bulkBufferLen; + numUrbs = (int32_t)request->length / bulkBufferLen; if ((request->length % bulkBufferLen) > 0) { numUrbs++; } diff --git a/usb/test/benchmarktest/BUILD.gn b/usb/test/benchmarktest/BUILD.gn index b8eee28e88..8612ab76d2 100644 --- a/usb/test/benchmarktest/BUILD.gn +++ b/usb/test/benchmarktest/BUILD.gn @@ -98,7 +98,7 @@ ohos_benchmarktest("hdf_usb_benchmark_request_test") { if (is_standard_system) { external_deps = [ - "drivers_interface_usb:libusb_proxy_1.0", + "drivers_interface_usb:libusb_proxy_1.1", "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", diff --git a/usb/test/benchmarktest/usb_benchmark_request_test.cpp b/usb/test/benchmarktest/usb_benchmark_request_test.cpp index f2afdcc4fe..fab2981ab9 100644 --- a/usb/test/benchmarktest/usb_benchmark_request_test.cpp +++ b/usb/test/benchmarktest/usb_benchmark_request_test.cpp @@ -28,9 +28,10 @@ using namespace OHOS; using namespace OHOS::USB; using namespace std; using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_1; namespace { -sptr g_usbInterface = nullptr; +sptr g_usbInterface = nullptr; struct UsbDev g_dev = {0, 0}; const int SLEEP_TIME = 3; @@ -76,7 +77,7 @@ int32_t SwitchErrCode(int32_t ret) void HdfUsbdBenchmarkRequestTest::SetUp(const ::benchmark::State& state) { - g_usbInterface = IUsbInterface::Get(); + g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); ASSERT_TRUE(g_usbInterface != nullptr); auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST); sleep(SLEEP_TIME); @@ -482,6 +483,58 @@ BENCHMARK_F(HdfUsbdBenchmarkRequestTest, BulkCancel)(benchmark::State& state) BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, BulkCancel)-> Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly(); + +/** + * @tc.name: ClearHalt + * @tc.desc: Test functions to ClearHalt benchmark test + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Positive test: parameters correctly + * @tc.type: FUNC + */ +BENCHMARK_F(HdfUsbdBenchmarkRequestTest, ClearHalt)(benchmark::State& state) +{ + ASSERT_TRUE(g_usbInterface != nullptr); + sptr subscriber = new UsbSubscriberTest(); + ASSERT_TRUE(subscriber != nullptr); + InitPara(subscriber); + uint8_t interfaceId = INTERFACEID_OK; + auto ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1); + EXPECT_EQ(ret, 0); + uint8_t pointId = POINTID_DIR_IN; + OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId}; + EXPECT_EQ(0, ret); + for (auto _ : state) { + ret = g_usbInterface->ClearHalt(g_dev, pipe); + } + ReleasePara(subscriber); +} + +BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, ClearHalt)-> + Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly(); + +/** + * @tc.name: ResetDevice + * @tc.desc: Test functions to ResetDevice benchmark test + * @tc.desc: int32_t ResetDevice(const UsbDev &dev); + * @tc.desc: Positive test: parameters correctly + * @tc.type: FUNC + */ +BENCHMARK_F(HdfUsbdBenchmarkRequestTest, ResetDevice)(benchmark::State& state) +{ + ASSERT_TRUE(g_usbInterface != nullptr); + sptr subscriber = new UsbSubscriberTest(); + ASSERT_TRUE(subscriber != nullptr); + InitPara(subscriber); + auto ret = 0; + for (auto _ : state) { + ret = g_usbInterface->ResetDevice(g_dev); + } + EXPECT_EQ(0, ret); + ReleasePara(subscriber); +} + +BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, ResetDevice)-> + Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly(); } // namespace BENCHMARK_MAIN(); diff --git a/usb/test/fuzztest/fuzztest.gni b/usb/test/fuzztest/fuzztest.gni index c1649c96f8..4fa5b24a0a 100644 --- a/usb/test/fuzztest/fuzztest.gni +++ b/usb/test/fuzztest/fuzztest.gni @@ -16,7 +16,7 @@ usb_test_fuzzer_external_deps = [] if (is_standard_system) { usb_test_fuzzer_external_deps = [ - "drivers_interface_usb:libusb_proxy_1.0", + "drivers_interface_usb:libusb_proxy_1.1", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn b/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn new file mode 100644 index 0000000000..a3e210e229 --- /dev/null +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbClearHaltFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbclearhalt_fuzzer" + + include_dirs = [ + "./../usbclearhalt_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + "./../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbclearhalt_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbClearHaltFuzzTest" ] +} diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/corpus/init b/usb/test/fuzztest/usbclearhalt_fuzzer/corpus/init new file mode 100644 index 0000000000..7e96755ef6 --- /dev/null +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/project.xml b/usb/test/fuzztest/usbclearhalt_fuzzer/project.xml new file mode 100644 index 0000000000..316fa2f549 --- /dev/null +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + \ No newline at end of file diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.cpp b/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.cpp new file mode 100644 index 0000000000..f5ba5cfb72 --- /dev/null +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "usbclearhalt_fuzzer.h" +#include "UsbSubscriberTest.h" +#include "hdf_log.h" +#include "securec.h" +#include "usbcommonfunction_fuzzer.h" +#include "v1_1/iusb_interface.h" + +using namespace OHOS::HDI::Usb::V1_1; + +namespace OHOS { +namespace USB { +bool UsbClearHaltFuzzTest(const uint8_t *data, size_t size) +{ + (void)size; + UsbDev dev; + sptr usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); + int32_t ret = UsbFuzzTestHostModeInit(dev, usbInterface); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: UsbFuzzTestHostModeInit failed", __func__); + return false; + } + + UsbPipe pipe; + if (memcpy_s((void *)&pipe, sizeof(pipe), data, sizeof(pipe)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s failed", __func__); + return false; + } + + ret = usbInterface->ClearHalt(dev, pipe); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%{public}s: ClearHalt succeed", __func__); + } + + ret = usbInterface->CloseDevice(dev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: close device failed", __func__); + return false; + } + return true; +} +} // namespace USB +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::USB::UsbClearHaltFuzzTest(data, size); + return 0; +} \ No newline at end of file diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.h b/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.h new file mode 100644 index 0000000000..196e3f0850 --- /dev/null +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/usbclearhalt_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USBCLEARHALT_FUZZER_H +#define USBCLEARHALT_FUZZER_H + +#define FUZZ_PROJECT_NAME "usbclearhalt_fuzzer" + +#endif \ No newline at end of file diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn b/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn new file mode 100644 index 0000000000..8452cd49a1 --- /dev/null +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbResetDeviceFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbresetdevice_fuzzer" + + include_dirs = [ + "./../usbresetdevice_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + "./../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbresetdevice_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbResetDeviceFuzzTest" ] +} diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/corpus/init b/usb/test/fuzztest/usbresetdevice_fuzzer/corpus/init new file mode 100644 index 0000000000..7e96755ef6 --- /dev/null +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/project.xml b/usb/test/fuzztest/usbresetdevice_fuzzer/project.xml new file mode 100644 index 0000000000..316fa2f549 --- /dev/null +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + \ No newline at end of file diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.cpp b/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.cpp new file mode 100644 index 0000000000..30229df237 --- /dev/null +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "usbresetdevice_fuzzer.h" +#include "UsbSubscriberTest.h" +#include "hdf_log.h" +#include "securec.h" +#include "usbcommonfunction_fuzzer.h" +#include "v1_1/iusb_interface.h" + +using namespace OHOS::HDI::Usb::V1_1; + +namespace OHOS { +namespace USB { +bool UsbResetDeviceFuzzTest(const uint8_t *data, size_t size) +{ + (void)size; + UsbDev dev; + sptr usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); + int32_t ret = UsbFuzzTestHostModeInit(dev, usbInterface); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: UsbFuzzTestHostModeInit failed", __func__); + return false; + } + + UsbDev devTmp; + if (memcpy_s((void *)&devTmp, sizeof(devTmp), data, sizeof(devTmp)) != EOK) { + HDF_LOGE("%{public}s: memcpy_s failed", __func__); + return false; + } + + ret = usbInterface->ResetDevice(devTmp); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%{public}s: set config succeed", __func__); + } + + ret = usbInterface->CloseDevice(dev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: close device failed", __func__); + return false; + } + return true; +} +} // namespace USB +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::USB::UsbResetDeviceFuzzTest(data, size); + return 0; +} \ No newline at end of file diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.h b/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.h new file mode 100644 index 0000000000..db617d41f9 --- /dev/null +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/usbresetdevice_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USBRESETDEVICE_FUZZER_H +#define USBRESETDEVICE_FUZZER_H + +#define FUZZ_PROJECT_NAME "usbresetdevice_fuzzer" + +#endif \ No newline at end of file diff --git a/usb/test/unittest/hal/src/usbd_device_status_test.cpp b/usb/test/unittest/hal/src/usbd_device_status_test.cpp index 52bc71b525..af6c1d4e13 100644 --- a/usb/test/unittest/hal/src/usbd_device_status_test.cpp +++ b/usb/test/unittest/hal/src/usbd_device_status_test.cpp @@ -29,6 +29,7 @@ const uint8_t DEV_ADDR_INVALID = 255; const uint8_t INTERFACEID_OK = 1; const uint8_t INTERFACEID_OK_NEW = 0; const uint8_t INTERFACEID_INVALID = 255; +const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2; using namespace testing::ext; using namespace OHOS; @@ -312,5 +313,188 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdGetInterfaceActiveStatus008, TestSize.Level1) __LINE__, ret, unactived); ASSERT_NE(ret, 0); } + +/** + * @tc.name: UsbdClearHalt001 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Positive test: parameters correctly + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt001, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_OK; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt001 %{public}d ClearHalt=%{public}d",__LINE__, ret); +} + +/** + * @tc.name: UsbdClearHalt002 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, busNum error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt002, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_OK; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.busNum = BUS_NUM_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt002 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt003 + * @tc.desc: Test functions to GetInterfaceActiveStatus + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, devAddr error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt003, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_OK; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt003 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt004 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, interfaceid error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt004, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_INVALID; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt004 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt005 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, busNum && devAddr error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt005, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_OK; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.busNum = BUS_NUM_INVALID; + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt006 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, busNum && interfaceid error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt006, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_INVALID; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt006 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.busNum = BUS_NUM_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt006 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt007 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt007, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_INVALID; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt007 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} + +/** + * @tc.name: UsbdClearHalt008 + * @tc.desc: Test functions to ClearHalt + * @tc.desc: int32_t ClearHalt(const UsbDev &dev, const UsbPipe &pipe); + * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt008, TestSize.Level1) +{ + struct UsbDev dev = dev_; + int32_t ret = -1; + uint8_t interfaceId = INTERFACEID_INVALID; + uint8_t pointId = POINTID_DIR_IN; + ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::UsbdClearHalt008 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + struct UsbPipe pipe = {interfaceId, pointId}; + dev.busNum = BUS_NUM_INVALID; + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ClearHalt(dev, pipe); + HDF_LOGI("UsbdClearHalt008 %{public}d ClearHalt=%{public}d",__LINE__, ret); + ASSERT_NE(0, ret); +} } // USB } // OHOS diff --git a/usb/test/unittest/hal/src/usbd_device_test.cpp b/usb/test/unittest/hal/src/usbd_device_test.cpp index c7ad715be4..33d7cb00ba 100644 --- a/usb/test/unittest/hal/src/usbd_device_test.cpp +++ b/usb/test/unittest/hal/src/usbd_device_test.cpp @@ -20,14 +20,15 @@ #include "UsbSubscriberTest.h" #include "hdf_log.h" -#include "v1_0/iusb_interface.h" -#include "v1_0/usb_types.h" +#include "v1_1/iusb_interface.h" +#include "v1_1/usb_types.h" using namespace testing::ext; using namespace OHOS; using namespace OHOS::USB; using namespace std; using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_1; const int SLEEP_TIME = 3; const uint8_t BUS_NUM_INVALID = 255; @@ -36,7 +37,7 @@ UsbDev UsbdDeviceTest::dev_ = {0, 0}; sptr UsbdDeviceTest::subscriber_ = nullptr; namespace { -sptr g_usbInterface = nullptr; +sptr g_usbInterface = nullptr; int32_t SwitchErrCode(int32_t ret) { @@ -45,7 +46,7 @@ int32_t SwitchErrCode(int32_t ret) void UsbdDeviceTest::SetUpTestCase(void) { - g_usbInterface = IUsbInterface::Get(); + g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get(); if (g_usbInterface == nullptr) { HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__); exit(0); @@ -223,4 +224,98 @@ HWTEST_F(UsbdDeviceTest, UsbdCloseDevice004, TestSize.Level1) dev = dev_; g_usbInterface->CloseDevice(dev); } + +/** + * @tc.name: UsbdResetDevice001 + * @tc.desc: Test functions to ResetDevice + * @tc.desc: int32_t ResetDevice(const UsbDev &dev); + * @tc.desc: 正向测试：参数正确 + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceTest, UsbdResetDevice001, TestSize.Level1) +{ + struct UsbDev dev = dev_; + auto ret = g_usbInterface->OpenDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + ret = g_usbInterface->ResetDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + ret = g_usbInterface->CloseDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); +} + +/** + * @tc.name: UsbdResetDevice002 + * @tc.desc: Test functions to ResetDevice + * @tc.desc: int32_t ResetDevice(const UsbDev &dev); + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceTest, UsbdResetDevice002, TestSize.Level1) +{ + struct UsbDev dev = dev_; + auto ret = g_usbInterface->OpenDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + dev.busNum = BUS_NUM_INVALID; + ret = g_usbInterface->ResetDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + ret = g_usbInterface->CloseDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret); + ASSERT_NE(ret, 0); + dev = dev_; + g_usbInterface->CloseDevice(dev); +} + +/** + * @tc.name: UsbdResetDevice003 + * @tc.desc: Test functions to ResetDevice + * @tc.desc: int32_t ResetDevice(const UsbDev &dev); + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceTest, UsbdResetDevice003, TestSize.Level1) +{ + struct UsbDev dev = dev_; + auto ret = g_usbInterface->OpenDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ResetDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + ret = g_usbInterface->CloseDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret); + ASSERT_NE(ret, 0); + dev = dev_; + g_usbInterface->CloseDevice(dev); +} + +/** + * @tc.name: UsbdResetDevice004 + * @tc.desc: Test functions to ResetDevice + * @tc.desc: int32_t ResetDevice(const UsbDev &dev); + * @tc.desc: + * @tc.type: FUNC + */ +HWTEST_F(UsbdDeviceTest, UsbdResetDevice004, TestSize.Level1) +{ + struct UsbDev dev = dev_; + auto ret = g_usbInterface->OpenDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); + dev.busNum = BUS_NUM_INVALID; + dev.devAddr = DEV_ADDR_INVALID; + ret = g_usbInterface->ResetDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d ResetDevice result=%{public}d", __LINE__, ret); + ASSERT_NE(0, ret); + ret = g_usbInterface->CloseDevice(dev); + HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret); + ASSERT_NE(ret, 0); + dev = dev_; + g_usbInterface->CloseDevice(dev); +} } // namespace -- Gitee From e22f772b3fd46940a9a8e7262339fd561957a66f Mon Sep 17 00:00:00 2001 From: luzhiye Date: Thu, 22 Aug 2024 12:30:54 +0000 Subject: [PATCH 0307/1485] =?UTF-8?q?=E6=97=A5=E5=BF=97=E8=B6=85=E9=99=90?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/host/src/linux_adapter.c | 2 +- usb/ddk/host/src/usb_raw_api_library.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/usb/ddk/host/src/linux_adapter.c b/usb/ddk/host/src/linux_adapter.c index 245e497330..1310c87fbb 100644 --- a/usb/ddk/host/src/linux_adapter.c +++ b/usb/ddk/host/src/linux_adapter.c @@ -514,7 +514,7 @@ static int32_t OsSubmitBulkRequestHandle( } if (i == 0) { - HDF_LOGE("submitUrb: ret=%{public}d errno=%{public}d length=%{public}d endPoint=%{public}d type=%{public}d", + HDF_LOGD("submitUrb: ret=%{public}d errno=%{public}d length=%{public}d endPoint=%{public}d type=%{public}d", ret, errno, urb->bufferLength, urb->endPoint, urb->type); return HDF_ERR_IO; } diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 26fb5e1ce2..ac949f7afc 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1477,7 +1477,7 @@ int32_t RawSubmitRequest(const struct UsbHostRequest *request) ret = osAdapterOps->submitRequest((struct UsbHostRequest *)request); if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s:%{public}d ret = %{public}d", __func__, __LINE__, ret); + HDF_LOGD("%{public}s:%{public}d ret = %{public}d", __func__, __LINE__, ret); } return ret; -- Gitee From 1429415d7e3abcd77a099d9d6335d6af14cfaf19 Mon Sep 17 00:00:00 2001 From: suozhipeng Date: Thu, 22 Aug 2024 16:10:38 +0800 Subject: [PATCH 0308/1485] fix: ut_bug Signed-off-by: suozhipeng --- power/test/unittest/src/hdf_power_runninglock_test.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/power/test/unittest/src/hdf_power_runninglock_test.cpp b/power/test/unittest/src/hdf_power_runninglock_test.cpp index f1fcf40926..20b2577f68 100644 --- a/power/test/unittest/src/hdf_power_runninglock_test.cpp +++ b/power/test/unittest/src/hdf_power_runninglock_test.cpp @@ -477,11 +477,11 @@ HWTEST_F(HdfPowerRunningLockTest, HdfPowerRunningLockTest012, TestSize.Level1) EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); - + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION; - EXPECT_EQ(HDF_ERR_INVALID_PARAM, RunningLockImpl::Hold(runinglockInfo, powerState)); - + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); + EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); runinglockInfo.type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK; EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Hold(runinglockInfo, powerState)); EXPECT_EQ(HDF_SUCCESS, RunningLockImpl::Unhold(runinglockInfo)); -- Gitee From fb050df12e9d647f51521659e821ab0601717a5e Mon Sep 17 00:00:00 2001 From: luzhiye Date: Thu, 22 Aug 2024 13:04:10 +0000 Subject: [PATCH 0309/1485] update usb/ddk/host/src/usb_raw_api_library.c. Signed-off-by: luzhiye --- usb/ddk/host/src/usb_raw_api_library.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index ac949f7afc..26fb5e1ce2 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1477,7 +1477,7 @@ int32_t RawSubmitRequest(const struct UsbHostRequest *request) ret = osAdapterOps->submitRequest((struct UsbHostRequest *)request); if (ret != HDF_SUCCESS) { - HDF_LOGD("%{public}s:%{public}d ret = %{public}d", __func__, __LINE__, ret); + HDF_LOGE("%{public}s:%{public}d ret = %{public}d", __func__, __LINE__, ret); } return ret; -- Gitee From c0bf90431583e07df9b7f9b130c8855606646359 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 13:10:10 +0000 Subject: [PATCH 0310/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd_ext.c | 295 ++++++++++++++++++ 1 file changed, 295 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index 6b21f358ec..c987c97f4c 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -66,6 +66,301 @@ struct HdfWpaStubData *HdfWpaStubDriver(void) return ®isterManager; } +int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +{ + int32_t ret = HDF_SUCCESS; + + if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { + HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); + if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, + tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, + (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, + (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill flags fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWifiWpaNetworkInfo->bssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->bssid); + hdiWifiWpaNetworkInfo->bssid = NULL; + } + if (hdiWifiWpaNetworkInfo->ssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->ssid); + hdiWifiWpaNetworkInfo->ssid = NULL; + } + if (hdiWifiWpaNetworkInfo->flags != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->flags); + hdiWifiWpaNetworkInfo->flags = NULL; + } + } + return ret; +} +//swx1355158 +static bool GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) +{ + if (strcmp(src, "") != 0) { + dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); + if (dst == NULL) { + HDF_LOGE("%{public}s OsalMemCalloc is NULL", __func__); + *dstLen = 0; + return FALSE; + } + *dstLen = strlen(src); + if (strcpy_s((char*)dst, strlen(src) + 1, src) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + return FALSE; + } + } + return TRUE; +} + +void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) +{ + if (halStatus == NULL) { + HDF_LOGE("%{public}s halStatus is NULL", __func__); + return; + } + status->id = halStatus->id; + status->freq = halStatus->freq; + if (GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt) == FALSE) { + HDF_LOGI("%{public}s get status->key_mgmt value=%{private}s failed", __func__, halStatus->keyMgmt); + // status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); + // if (status->keyMgmt == NULL) { + // HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); + // status->keyMgmtLen = 0; + // return; + // } + // status->keyMgmtLen = strlen(halStatus->keyMgmt); + // if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { + // HDF_LOGE("%{public}s strcpy failed", __func__); + // } + } + // if (strcmp(halStatus->ssid, "") != 0) { + if (GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid) == FALSE) { + HDF_LOGI("%{public}s get status->ssid value=%{private}s failed", __func__, halStatus->keyMgmt); + // status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); + // if (status->ssid == NULL) { + // HDF_LOGE("%{public}s status->ssid is NULL", __func__); + // status->ssidLen = 0; + // return; + // } + // status->ssidLen = strlen(halStatus->ssid); + // if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { + // HDF_LOGE("%{public}s strcpy failed", __func__); + // } + } + if (strcmp(halStatus->address, "") != 0) { + HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); + // uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; + // hwaddr_aton(halStatus->address, tmpAddress); + status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->address == NULL) { + HDF_LOGE("%{public}s status->address is NULL", __func__); + status->addressLen = 0; + return; + } + status->addressLen = ETH_ADDR_LEN + 1 ; + hwaddr_aton(halStatus->address, status->address); + // if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { + // HDF_LOGE("%{public}s strcpy memcpy", __func__); + // } + } + if (strcmp(halStatus->bssid, "") != 0) { + HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); + // uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; + // hwaddr_aton(halStatus->bssid, tmpBssid); + status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->bssid == NULL) { + HDF_LOGE("%{public}s status->bssid is NULL", __func__); + status->bssidLen = 0; + return; + } + status->bssidLen = ETH_ADDR_LEN + 1 ; + hwaddr_aton(halStatus->bssid, status->bssid); + // if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { + // HDF_LOGE("%{public}s strcpy failed", __func__); + // } + } +} + +const char *macToStr(const u8 *addr) +{ + const int macAddrIndexOne = 0; + const int macAddrIndexTwo = 1; + const int macAddrIndexThree = 2; + const int macAddrIndexFour = 3; + const int macAddrIndexFive = 4; + const int macAddrIndexSix = 5; + static char macToStr[WIFI_BSSID_LENGTH]; + if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", + addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], + addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { + return NULL; + } + return macToStr; +} + +void HdfWpaDelRemoteObj(struct IWpaCallback *self) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct HdfWpaRemoteNode *tmp = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { + if (pos->service->index == self->AsObject(self)->index) { + DListRemove(&(pos->node)); + IWpaCallbackRelease(pos->callbackObj); + OsalMemFree(pos); + pos = NULL; + break; + } + } + IWpaCallbackRelease(self); +} + +int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { + HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; + hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; + if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, + disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaDisconnectParam->bssid != NULL) { + OsalMemFree(hdiWpaDisconnectParam->bssid); + hdiWpaDisconnectParam->bssid = NULL; + } + } + return ret; +} + +int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) +{ + int32_t ret = HDF_SUCCESS; + + if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { + HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, + bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, + bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill reason fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaBssidChangedParam->bssid != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->bssid); + hdiWpaBssidChangedParam->bssid = NULL; + } + if (hdiWpaBssidChangedParam->reason != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->reason); + hdiWpaBssidChangedParam->reason = NULL; + } + } + return ret; +} +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "wpa_common_cmd.h" +#include "wpa_p2p_cmd.h" +#include "hdi_wpa_hal.h" +#include +#include +#include +#include +#include +#include +#include "utils/common.h" +#include "wpa_supplicant_i.h" +#include "ctrl_iface.h" +#include "main.h" +#include "wps_supplicant.h" +#include "bssid_ignore.h" +#include "wpa_supplicant/config.h" +#include "common/defs.h" +#include "v1_1/iwpa_callback.h" +#include "v1_1/iwpa_interface.h" + +#include +#include +#include +#include +#include "hdi_wpa_common.h" + +int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) +{ + if (src == NULL || dst == NULL || dstLen == NULL) { + HDF_LOGE("%{public}s: Invalid parameter!", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); + if (srcLen > 0) { + *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); + if (*dst == NULL) { + HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); + return HDF_FAILURE; + } + if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { + HDF_LOGE("%{public}s: memcpy_s fail!", __func__); + return HDF_FAILURE; + } + } + *dstLen = srcLen; + return HDF_SUCCESS; +} + +struct HdfWpaStubData *HdfWpaStubDriver(void) +{ + static struct HdfWpaStubData registerManager; + return ®isterManager; +} + int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) { -- Gitee From 2b3947251b4f32a83508c63f6394afd9b31a385e Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 13:11:07 +0000 Subject: [PATCH 0311/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h. Signed-off-by: xionglei --- .../interfaces/hdi_service/service_common/wpa_common_cmd.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 79c9d7e3e8..1e2d9bcbb6 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -112,14 +112,9 @@ int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo); void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status); -void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote); -void AddDeathRecipientForService(struct IWpaCallback *cbFunc); -int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName); void HdfWpaDelRemoteObj(struct IWpaCallback *self); int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, struct HdiWpaDisconnectParam *hdiWpaDisconnectParam); -int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, - struct HdiWpaConnectParam *hdiWpaConnectParam); int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam); -- Gitee From 4d7a615b8d3e5a8df1bf7d891d0185f3281d1054 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 13:12:54 +0000 Subject: [PATCH 0312/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd.c | 270 ++++++++- .../service_common/wpa_common_cmd.h | 7 - .../service_common/wpa_common_cmd_ext.c | 557 ------------------ 3 files changed, 256 insertions(+), 578 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 5d3fdad6b6..e615087fbc 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -252,13 +252,8 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: input parameter invalid!", __func__); return HDF_ERR_INVALID_PARAM; } - HDF_LOGI("enter %{public}s networkId = %{public}d", __func__, networkId); - if (name != NULL) { - HDF_LOGI("%{public}s name = %{private}s", __func__, name); - } - if (value != NULL) { - HDF_LOGI("%{public}s value = %{private}s", __func__, value); - } + HDF_LOGI("enter %{public}s networkId = %{public}d name = %{private}s value = %{private}s", __func__, networkId, + name, value); pthread_mutex_lock(&g_interfaceLock); WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); if (pStaIfc == NULL) { @@ -266,12 +261,7 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); return HDF_FAILURE; } - struct WpaSetNetworkArgv conf; - if (memset_s(&conf, sizeof(conf), 0, sizeof(conf)) != 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: memset_s conf fail", __func__); - return HDF_FAILURE; - } + struct WpaSetNetworkArgv conf = {0}; conf.id = networkId; int pos = -1; for (int i = 0; i < (int)(sizeof(g_wpaSsidFields) / sizeof(g_wpaSsidFields[0])); ++i) { @@ -302,6 +292,52 @@ int32_t WpaInterfaceSetNetwork(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } +static int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, + struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) +{ + int32_t ret = HDF_SUCCESS; + + if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { + HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; + hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); + if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, + tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, + (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill ssid fail!", __func__); + ret = HDF_FAILURE; + } + if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, + (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill flags fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWifiWpaNetworkInfo->bssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->bssid); + hdiWifiWpaNetworkInfo->bssid = NULL; + } + if (hdiWifiWpaNetworkInfo->ssid != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->ssid); + hdiWifiWpaNetworkInfo->ssid = NULL; + } + if (hdiWifiWpaNetworkInfo->flags != NULL) { + OsalMemFree(hdiWifiWpaNetworkInfo->flags); + hdiWifiWpaNetworkInfo->flags = NULL; + } + } + return ret; +} + //need to check int32_t WpaInterfaceListNetworks(struct IWpaInterface *self, const char *ifName, struct HdiWifiWpaNetworkInfo *networkInfo, uint32_t *networkInfoLen) @@ -504,6 +540,62 @@ int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } +static bool GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) +{ + if (strcmp(src, "") != 0) { + dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); + if (dst == NULL) { + HDF_LOGE("%{public}s OsalMemCalloc is NULL", __func__); + *dstLen = 0; + return FALSE; + } + *dstLen = strlen(src); + if (strcpy_s((char*)dst, strlen(src) + 1, src) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + return FALSE; + } + } + return TRUE; +} + +static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) +{ + if (halStatus == NULL) { + HDF_LOGE("%{public}s halStatus is NULL", __func__); + return; + } + status->id = halStatus->id; + status->freq = halStatus->freq; + if (GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt) == FALSE) { + HDF_LOGI("%{public}s get status->key_mgmt value=%{private}s failed", __func__, halStatus->keyMgmt); + } + if (GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid) == FALSE) { + HDF_LOGI("%{public}s get status->ssid value=%{private}s failed", __func__, halStatus->keyMgmt); + } + if (strcmp(halStatus->address, "") != 0) { + HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); + status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->address == NULL) { + HDF_LOGE("%{public}s status->address is NULL", __func__); + status->addressLen = 0; + return; + } + status->addressLen = ETH_ADDR_LEN + 1 ; + hwaddr_aton(halStatus->address, status->address); + } + if (strcmp(halStatus->bssid, "") != 0) { + HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); + status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); + if (status->bssid == NULL) { + HDF_LOGE("%{public}s status->bssid is NULL", __func__); + status->bssidLen = 0; + return; + } + status->bssidLen = ETH_ADDR_LEN + 1 ; + hwaddr_aton(halStatus->bssid, status->bssid); + } +} + int32_t WpaInterfaceWifiStatus(struct IWpaInterface *self, const char *ifName, struct HdiWpaCmdStatus *status) { HDF_LOGI("enter %{public}s", __func__); @@ -571,6 +663,23 @@ int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) return HDF_SUCCESS; } +static const char *macToStr(const u8 *addr) +{ + const int macAddrIndexOne = 0; + const int macAddrIndexTwo = 1; + const int macAddrIndexThree = 2; + const int macAddrIndexFour = 3; + const int macAddrIndexFive = 4; + const int macAddrIndexSix = 5; + static char macToStr[WIFI_BSSID_LENGTH]; + if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", + addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], + addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { + return NULL; + } + return macToStr; +} + int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) { HDF_LOGI("enter %{public}s ", __func__); @@ -1007,13 +1116,31 @@ int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifNam return HDF_SUCCESS; } +static void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) +{ + HDF_LOGI("enter %{public}s ", __func__); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); + return; + } + int ret = pWpaInterface->wpaCliTerminate(); + if (ret != 0) { + HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); + } else { + HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); + } + ReleaseWpaGlobalInterface(); + HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); +} + static struct RemoteServiceDeathRecipient g_deathRecipient = { .recipient = { .OnRemoteDied = OnRemoteServiceDied, } }; -void AddDeathRecipientForService(struct IWpaCallback *cbFunc) +static void AddDeathRecipientForService(struct IWpaCallback *cbFunc) { HDF_LOGI("enter %{public}s ", __func__); if (cbFunc == NULL) { @@ -1028,6 +1155,121 @@ void AddDeathRecipientForService(struct IWpaCallback *cbFunc) HdfRemoteServiceAddDeathRecipient(remote, &g_deathRecipient.recipient); } +static int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) +{ + struct HdfWpaRemoteNode *pos = NULL; + struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; + + if (self == NULL) { + HDF_LOGE("%{public}s:self == NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!DListIsEmpty(head)) { + DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { + if (pos->service == self->AsObject(self)) { + HDF_LOGE("%{public}s: pos->service == self", __func__); + return HDF_FAILURE; + } + } + } + struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); + if (newRemoteNode == NULL) { + HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); + return HDF_FAILURE; + } + newRemoteNode->callbackObj = self; + newRemoteNode->service = self->AsObject(self); + DListInsertTail(&newRemoteNode->node, head); + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + AddDeathRecipientForService(self); + } + return HDF_SUCCESS; +} + +static int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, + struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { + HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; + hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; + if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, + disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaDisconnectParam->bssid != NULL) { + OsalMemFree(hdiWpaDisconnectParam->bssid); + hdiWpaDisconnectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, + struct HdiWpaConnectParam *hdiWpaConnectParam) +{ + int32_t ret = HDF_SUCCESS; + + if (connectParam == NULL || hdiWpaConnectParam == NULL) { + HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + hdiWpaConnectParam->networkId = connectParam->networkId; + if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, + connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + } + if (ret != HDF_SUCCESS) { + if (hdiWpaConnectParam->bssid != NULL) { + OsalMemFree(hdiWpaConnectParam->bssid); + hdiWpaConnectParam->bssid = NULL; + } + } + return ret; +} + +static int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, + struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) +{ + int32_t ret = HDF_SUCCESS; + + if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { + HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + do { + if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, + bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill bssid fail!", __func__); + ret = HDF_FAILURE; + break; + } + if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, + bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fill reason fail!", __func__); + ret = HDF_FAILURE; + } + } while (0); + if (ret != HDF_SUCCESS) { + if (hdiWpaBssidChangedParam->bssid != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->bssid); + hdiWpaBssidChangedParam->bssid = NULL; + } + if (hdiWpaBssidChangedParam->reason != NULL) { + OsalMemFree(hdiWpaBssidChangedParam->reason); + hdiWpaBssidChangedParam->reason = NULL; + } + } + return ret; +} + static int32_t WpaFillWpaStateChangedParam(struct WpaStateChangedParam *stateChangedParam, struct HdiWpaStateChangedParam *hdiWpaStateChangedParam) { diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 1e2d9bcbb6..4c4336986e 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -109,14 +109,7 @@ int32_t WpaInterfaceSetCountryCode(struct IWpaInterface *self, const char *ifNam int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName); int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd); -int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo); -void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status); void HdfWpaDelRemoteObj(struct IWpaCallback *self); -int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam); -int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam); int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen); pthread_mutex_t *GetInterfaceLock(); diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index c987c97f4c..badf1cc59a 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -66,156 +66,6 @@ struct HdfWpaStubData *HdfWpaStubDriver(void) return ®isterManager; } -int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) -{ - int32_t ret = HDF_SUCCESS; - - if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { - HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); - if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, - tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, - (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, - (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill flags fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWifiWpaNetworkInfo->bssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->bssid); - hdiWifiWpaNetworkInfo->bssid = NULL; - } - if (hdiWifiWpaNetworkInfo->ssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->ssid); - hdiWifiWpaNetworkInfo->ssid = NULL; - } - if (hdiWifiWpaNetworkInfo->flags != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->flags); - hdiWifiWpaNetworkInfo->flags = NULL; - } - } - return ret; -} -//swx1355158 -static bool GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) -{ - if (strcmp(src, "") != 0) { - dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); - if (dst == NULL) { - HDF_LOGE("%{public}s OsalMemCalloc is NULL", __func__); - *dstLen = 0; - return FALSE; - } - *dstLen = strlen(src); - if (strcpy_s((char*)dst, strlen(src) + 1, src) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - return FALSE; - } - } - return TRUE; -} - -void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) -{ - if (halStatus == NULL) { - HDF_LOGE("%{public}s halStatus is NULL", __func__); - return; - } - status->id = halStatus->id; - status->freq = halStatus->freq; - if (GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt) == FALSE) { - HDF_LOGI("%{public}s get status->key_mgmt value=%{private}s failed", __func__, halStatus->keyMgmt); - // status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); - // if (status->keyMgmt == NULL) { - // HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); - // status->keyMgmtLen = 0; - // return; - // } - // status->keyMgmtLen = strlen(halStatus->keyMgmt); - // if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { - // HDF_LOGE("%{public}s strcpy failed", __func__); - // } - } - // if (strcmp(halStatus->ssid, "") != 0) { - if (GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid) == FALSE) { - HDF_LOGI("%{public}s get status->ssid value=%{private}s failed", __func__, halStatus->keyMgmt); - // status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); - // if (status->ssid == NULL) { - // HDF_LOGE("%{public}s status->ssid is NULL", __func__); - // status->ssidLen = 0; - // return; - // } - // status->ssidLen = strlen(halStatus->ssid); - // if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { - // HDF_LOGE("%{public}s strcpy failed", __func__); - // } - } - if (strcmp(halStatus->address, "") != 0) { - HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); - // uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; - // hwaddr_aton(halStatus->address, tmpAddress); - status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->address == NULL) { - HDF_LOGE("%{public}s status->address is NULL", __func__); - status->addressLen = 0; - return; - } - status->addressLen = ETH_ADDR_LEN + 1 ; - hwaddr_aton(halStatus->address, status->address); - // if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { - // HDF_LOGE("%{public}s strcpy memcpy", __func__); - // } - } - if (strcmp(halStatus->bssid, "") != 0) { - HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); - // uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; - // hwaddr_aton(halStatus->bssid, tmpBssid); - status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->bssid == NULL) { - HDF_LOGE("%{public}s status->bssid is NULL", __func__); - status->bssidLen = 0; - return; - } - status->bssidLen = ETH_ADDR_LEN + 1 ; - hwaddr_aton(halStatus->bssid, status->bssid); - // if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { - // HDF_LOGE("%{public}s strcpy failed", __func__); - // } - } -} - -const char *macToStr(const u8 *addr) -{ - const int macAddrIndexOne = 0; - const int macAddrIndexTwo = 1; - const int macAddrIndexThree = 2; - const int macAddrIndexFour = 3; - const int macAddrIndexFive = 4; - const int macAddrIndexSix = 5; - static char macToStr[WIFI_BSSID_LENGTH]; - if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", - addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], - addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { - return NULL; - } - return macToStr; -} - void HdfWpaDelRemoteObj(struct IWpaCallback *self) { struct HdfWpaRemoteNode *pos = NULL; @@ -233,410 +83,3 @@ void HdfWpaDelRemoteObj(struct IWpaCallback *self) } IWpaCallbackRelease(self); } - -int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { - HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; - hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; - if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, - disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaDisconnectParam->bssid != NULL) { - OsalMemFree(hdiWpaDisconnectParam->bssid); - hdiWpaDisconnectParam->bssid = NULL; - } - } - return ret; -} - -int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) -{ - int32_t ret = HDF_SUCCESS; - - if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { - HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, - bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, - bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill reason fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaBssidChangedParam->bssid != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->bssid); - hdiWpaBssidChangedParam->bssid = NULL; - } - if (hdiWpaBssidChangedParam->reason != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->reason); - hdiWpaBssidChangedParam->reason = NULL; - } - } - return ret; -} -/* - * Copyright (c) 2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "wpa_common_cmd.h" -#include "wpa_p2p_cmd.h" -#include "hdi_wpa_hal.h" -#include -#include -#include -#include -#include -#include -#include "utils/common.h" -#include "wpa_supplicant_i.h" -#include "ctrl_iface.h" -#include "main.h" -#include "wps_supplicant.h" -#include "bssid_ignore.h" -#include "wpa_supplicant/config.h" -#include "common/defs.h" -#include "v1_1/iwpa_callback.h" -#include "v1_1/iwpa_interface.h" - -#include -#include -#include -#include -#include "hdi_wpa_common.h" - -int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) -{ - if (src == NULL || dst == NULL || dstLen == NULL) { - HDF_LOGE("%{public}s: Invalid parameter!", __func__); - return HDF_ERR_INVALID_PARAM; - } - HDF_LOGD("%{public}s: srcLen =%{public}d ", __func__, srcLen); - if (srcLen > 0) { - *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * srcLen); - if (*dst == NULL) { - HDF_LOGE("%{public}s: OsalMemCalloc fail!", __func__); - return HDF_FAILURE; - } - if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { - HDF_LOGE("%{public}s: memcpy_s fail!", __func__); - return HDF_FAILURE; - } - } - *dstLen = srcLen; - return HDF_SUCCESS; -} - -struct HdfWpaStubData *HdfWpaStubDriver(void) -{ - static struct HdfWpaStubData registerManager; - return ®isterManager; -} - -int32_t WpaFillWpaListNetworkParam(struct WifiNetworkInfo *wifiWpaNetworkInfo, - struct HdiWifiWpaNetworkInfo *hdiWifiWpaNetworkInfo) -{ - int32_t ret = HDF_SUCCESS; - - if (wifiWpaNetworkInfo == NULL || hdiWifiWpaNetworkInfo == NULL) { - HDF_LOGE("%{public}s: wifiWpaNetworkInfo or hdiWifiWpaNetworkInfo is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - uint8_t tmpBssid[ETH_ADDR_LEN] = {0}; - hwaddr_aton(wifiWpaNetworkInfo->bssid, tmpBssid); - if (FillData(&hdiWifiWpaNetworkInfo->bssid, &hdiWifiWpaNetworkInfo->bssidLen, - tmpBssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWifiWpaNetworkInfo->ssid, &hdiWifiWpaNetworkInfo->ssidLen, - (uint8_t *)wifiWpaNetworkInfo->ssid, strlen(wifiWpaNetworkInfo->ssid)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill ssid fail!", __func__); - ret = HDF_FAILURE; - } - if (FillData(&hdiWifiWpaNetworkInfo->flags, &hdiWifiWpaNetworkInfo->flagsLen, - (uint8_t *)wifiWpaNetworkInfo->flags, strlen(wifiWpaNetworkInfo->flags)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill flags fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWifiWpaNetworkInfo->bssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->bssid); - hdiWifiWpaNetworkInfo->bssid = NULL; - } - if (hdiWifiWpaNetworkInfo->ssid != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->ssid); - hdiWifiWpaNetworkInfo->ssid = NULL; - } - if (hdiWifiWpaNetworkInfo->flags != NULL) { - OsalMemFree(hdiWifiWpaNetworkInfo->flags); - hdiWifiWpaNetworkInfo->flags = NULL; - } - } - return ret; -} - -void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) -{ - if (halStatus == NULL) { - HDF_LOGE("%{public}s halStatus is NULL", __func__); - return; - } - status->id = halStatus->id; - status->freq = halStatus->freq; - if (strcmp(halStatus->keyMgmt, "") != 0) { - HDF_LOGI("%{public}s key include key_mgmt value=%{private}s", __func__, halStatus->keyMgmt); - status->keyMgmt = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->keyMgmt) + 1)); - if (status->keyMgmt == NULL) { - HDF_LOGE("%{public}s status->keyMgmt is NULL", __func__); - status->keyMgmtLen = 0; - return; - } - status->keyMgmtLen = strlen(halStatus->keyMgmt); - if (strcpy_s((char *)status->keyMgmt, strlen(halStatus->keyMgmt) + 1, halStatus->keyMgmt) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->ssid, "") != 0) { - HDF_LOGI("%{public}s key include ssid value=%{private}s", __func__, halStatus->ssid); - status->ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(halStatus->ssid) + 1)); - if (status->ssid == NULL) { - HDF_LOGE("%{public}s status->ssid is NULL", __func__); - status->ssidLen = 0; - return; - } - status->ssidLen = strlen(halStatus->ssid); - if (strcpy_s((char *)status->ssid, strlen(halStatus->ssid) + 1, halStatus->ssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } - if (strcmp(halStatus->address, "") != 0) { - HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); - uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->address, tmpAddress); - status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->address == NULL) { - HDF_LOGE("%{public}s status->address is NULL", __func__); - status->addressLen = 0; - return; - } - status->addressLen = ETH_ADDR_LEN + 1 ; - if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { - HDF_LOGE("%{public}s strcpy memcpy", __func__); - } - } - if (strcmp(halStatus->bssid, "") != 0) { - HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); - uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; - hwaddr_aton(halStatus->bssid, tmpBssid); - status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); - if (status->bssid == NULL) { - HDF_LOGE("%{public}s status->bssid is NULL", __func__); - status->bssidLen = 0; - return; - } - status->bssidLen = ETH_ADDR_LEN + 1 ; - if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { - HDF_LOGE("%{public}s strcpy failed", __func__); - } - } -} - -const char *macToStr(const u8 *addr) -{ - const int macAddrIndexOne = 0; - const int macAddrIndexTwo = 1; - const int macAddrIndexThree = 2; - const int macAddrIndexFour = 3; - const int macAddrIndexFive = 4; - const int macAddrIndexSix = 5; - static char macToStr[WIFI_BSSID_LENGTH]; - if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", - addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], - addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { - return NULL; - } - return macToStr; -} - -void OnRemoteServiceDied(struct HdfDeathRecipient *deathRecipient, struct HdfRemoteService *remote) -{ - HDF_LOGI("enter %{public}s ", __func__); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); - return; - } - int ret = pWpaInterface->wpaCliTerminate(); - if (ret != 0) { - HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); - } else { - HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); - } - ReleaseWpaGlobalInterface(); - HDF_LOGI("%{public}s: call ReleaseWpaGlobalInterface finish", __func__); -} - -int32_t HdfWpaAddRemoteObj(struct IWpaCallback *self, const char *ifName) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - if (self == NULL) { - HDF_LOGE("%{public}s:self == NULL", __func__); - return HDF_ERR_INVALID_PARAM; - } - if (!DListIsEmpty(head)) { - DLIST_FOR_EACH_ENTRY(pos, head, struct HdfWpaRemoteNode, node) { - if (pos->service == self->AsObject(self)) { - HDF_LOGE("%{public}s: pos->service == self", __func__); - return HDF_FAILURE; - } - } - } - struct HdfWpaRemoteNode *newRemoteNode = (struct HdfWpaRemoteNode *)OsalMemCalloc(sizeof(struct HdfWpaRemoteNode)); - if (newRemoteNode == NULL) { - HDF_LOGE("%{public}s:newRemoteNode is NULL", __func__); - return HDF_FAILURE; - } - newRemoteNode->callbackObj = self; - newRemoteNode->service = self->AsObject(self); - DListInsertTail(&newRemoteNode->node, head); - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - AddDeathRecipientForService(self); - } - return HDF_SUCCESS; -} - -void HdfWpaDelRemoteObj(struct IWpaCallback *self) -{ - struct HdfWpaRemoteNode *pos = NULL; - struct HdfWpaRemoteNode *tmp = NULL; - struct DListHead *head = &HdfWpaStubDriver()->remoteListHead; - - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct HdfWpaRemoteNode, node) { - if (pos->service->index == self->AsObject(self)->index) { - DListRemove(&(pos->node)); - IWpaCallbackRelease(pos->callbackObj); - OsalMemFree(pos); - pos = NULL; - break; - } - } - IWpaCallbackRelease(self); -} - -int32_t WpaFillWpaDisconnectParam(struct WpaDisconnectParam *disconnectParam, - struct HdiWpaDisconnectParam *hdiWpaDisconnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (disconnectParam == NULL || hdiWpaDisconnectParam == NULL) { - HDF_LOGE("%{public}s: disconnectParam or hdiWpaDisconnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaDisconnectParam->locallyGenerated = disconnectParam->locallyGenerated; - hdiWpaDisconnectParam->reasonCode = disconnectParam->reasonCode; - if (FillData(&hdiWpaDisconnectParam->bssid, &hdiWpaDisconnectParam->bssidLen, - disconnectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaDisconnectParam->bssid != NULL) { - OsalMemFree(hdiWpaDisconnectParam->bssid); - hdiWpaDisconnectParam->bssid = NULL; - } - } - return ret; -} - -int32_t WpaFillWpaConnectParam(struct WpaConnectParam *connectParam, - struct HdiWpaConnectParam *hdiWpaConnectParam) -{ - int32_t ret = HDF_SUCCESS; - - if (connectParam == NULL || hdiWpaConnectParam == NULL) { - HDF_LOGE("%{public}s: connectParam or hdiWpaConnectParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - hdiWpaConnectParam->networkId = connectParam->networkId; - if (FillData(&hdiWpaConnectParam->bssid, &hdiWpaConnectParam->bssidLen, - connectParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - } - if (ret != HDF_SUCCESS) { - if (hdiWpaConnectParam->bssid != NULL) { - OsalMemFree(hdiWpaConnectParam->bssid); - hdiWpaConnectParam->bssid = NULL; - } - } - return ret; -} - -int32_t WpaFillWpaBssidChangedParam(struct WpaBssidChangedParam *bssidChangedParam, - struct HdiWpaBssidChangedParam *hdiWpaBssidChangedParam) -{ - int32_t ret = HDF_SUCCESS; - - if (bssidChangedParam == NULL || hdiWpaBssidChangedParam == NULL) { - HDF_LOGE("%{public}s: bssidChangedParam or hdiWpaBssidChangedParam is NULL!", __func__); - return HDF_ERR_INVALID_PARAM; - } - do { - if (FillData(&hdiWpaBssidChangedParam->bssid, &hdiWpaBssidChangedParam->bssidLen, - bssidChangedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill bssid fail!", __func__); - ret = HDF_FAILURE; - break; - } - if (FillData(&hdiWpaBssidChangedParam->reason, &hdiWpaBssidChangedParam->reasonLen, - bssidChangedParam->reason, strlen((char*) bssidChangedParam->reason)) != HDF_SUCCESS) { - HDF_LOGE("%{public}s: fill reason fail!", __func__); - ret = HDF_FAILURE; - } - } while (0); - if (ret != HDF_SUCCESS) { - if (hdiWpaBssidChangedParam->bssid != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->bssid); - hdiWpaBssidChangedParam->bssid = NULL; - } - if (hdiWpaBssidChangedParam->reason != NULL) { - OsalMemFree(hdiWpaBssidChangedParam->reason); - hdiWpaBssidChangedParam->reason = NULL; - } - } - return ret; -} -- Gitee From 08660c73ecbe43ad08a98868fac7988ca7108770 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Fri, 23 Aug 2024 00:35:49 +0000 Subject: [PATCH 0313/1485] add tests for clearhalt and resetdevice MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- .../fuzztest/usbclearhalt_fuzzer/BUILD.gn | 108 +++++++++--------- .../fuzztest/usbresetdevice_fuzzer/BUILD.gn | 108 +++++++++--------- .../hal/src/usbd_device_status_test.cpp | 16 +-- 3 files changed, 116 insertions(+), 116 deletions(-) diff --git a/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn b/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn index a3e210e229..0a6ac0ab86 100644 --- a/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn +++ b/usb/test/fuzztest/usbclearhalt_fuzzer/BUILD.gn @@ -1,55 +1,55 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and # limitations under the License. - -import("//build/config/features.gni") -import("//build/ohos.gni") -import("//build/test.gni") -import("./../fuzztest.gni") -module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" - -ohos_fuzztest("UsbClearHaltFuzzTest") { - module_out_path = module_output_path - - fuzz_config_file = "./../usbclearhalt_fuzzer" - - include_dirs = [ - "./../usbclearhalt_fuzzer", - "./../../UsbSubscriberTest", - "./../usbcommonfunction_fuzzer", - "./../../../../../base/usb/usb_manager/utils/native/include", - "../../../hdi_service/include", - ] - - deps = [ "./../../../ddk:libusb_core" ] - - external_deps = usb_test_fuzzer_external_deps - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", - "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", - "usbclearhalt_fuzzer.cpp", - ] -} - -group("fuzztest") { - testonly = true - deps = [] - deps += [ ":UsbClearHaltFuzzTest" ] -} + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbClearHaltFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbclearhalt_fuzzer" + + include_dirs = [ + "./../usbclearhalt_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + "./../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbclearhalt_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbClearHaltFuzzTest" ] +} diff --git a/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn b/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn index 8452cd49a1..70bbe721e0 100644 --- a/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn +++ b/usb/test/fuzztest/usbresetdevice_fuzzer/BUILD.gn @@ -1,55 +1,55 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and # limitations under the License. - -import("//build/config/features.gni") -import("//build/ohos.gni") -import("//build/test.gni") -import("./../fuzztest.gni") -module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" - -ohos_fuzztest("UsbResetDeviceFuzzTest") { - module_out_path = module_output_path - - fuzz_config_file = "./../usbresetdevice_fuzzer" - - include_dirs = [ - "./../usbresetdevice_fuzzer", - "./../../UsbSubscriberTest", - "./../usbcommonfunction_fuzzer", - "./../../../../../base/usb/usb_manager/utils/native/include", - "../../../hdi_service/include", - ] - - deps = [ "./../../../ddk:libusb_core" ] - - external_deps = usb_test_fuzzer_external_deps - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", - "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", - "usbresetdevice_fuzzer.cpp", - ] -} - -group("fuzztest") { - testonly = true - deps = [] - deps += [ ":UsbResetDeviceFuzzTest" ] -} + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../fuzztest.gni") +module_output_path = "drivers_peripheral_usb/drivers_peripheral_usb" + +ohos_fuzztest("UsbResetDeviceFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = "./../usbresetdevice_fuzzer" + + include_dirs = [ + "./../usbresetdevice_fuzzer", + "./../../UsbSubscriberTest", + "./../usbcommonfunction_fuzzer", + "./../../../../../base/usb/usb_manager/utils/native/include", + "../../../hdi_service/include", + ] + + deps = [ "./../../../ddk:libusb_core" ] + + external_deps = usb_test_fuzzer_external_deps + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "./../../UsbSubscriberTest/UsbSubscriberTest.cpp", + "./../usbcommonfunction_fuzzer/usbcommonfunction_fuzzer.cpp", + "usbresetdevice_fuzzer.cpp", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ ":UsbResetDeviceFuzzTest" ] +} diff --git a/usb/test/unittest/hal/src/usbd_device_status_test.cpp b/usb/test/unittest/hal/src/usbd_device_status_test.cpp index af6c1d4e13..2b1789359a 100644 --- a/usb/test/unittest/hal/src/usbd_device_status_test.cpp +++ b/usb/test/unittest/hal/src/usbd_device_status_test.cpp @@ -332,7 +332,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt001, TestSize.Level1) ASSERT_EQ(0, ret); struct UsbPipe pipe = {interfaceId, pointId}; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt001 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt001 %{public}d ClearHalt=%{public}d", __LINE__, ret); } /** @@ -354,7 +354,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt002, TestSize.Level1) struct UsbPipe pipe = {interfaceId, pointId}; dev.busNum = BUS_NUM_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt002 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt002 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -377,7 +377,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt003, TestSize.Level1) struct UsbPipe pipe = {interfaceId, pointId}; dev.devAddr = DEV_ADDR_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt003 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt003 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -399,7 +399,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt004, TestSize.Level1) ASSERT_NE(0, ret); struct UsbPipe pipe = {interfaceId, pointId}; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt004 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt004 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -423,7 +423,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt005, TestSize.Level1) dev.busNum = BUS_NUM_INVALID; dev.devAddr = DEV_ADDR_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -446,7 +446,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt006, TestSize.Level1) struct UsbPipe pipe = {interfaceId, pointId}; dev.busNum = BUS_NUM_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt006 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt006 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -469,7 +469,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt007, TestSize.Level1) struct UsbPipe pipe = {interfaceId, pointId}; dev.devAddr = DEV_ADDR_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt005 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } @@ -493,7 +493,7 @@ HWTEST_F(UsbdDeviceStatusTest, UsbdClearHalt008, TestSize.Level1) dev.busNum = BUS_NUM_INVALID; dev.devAddr = DEV_ADDR_INVALID; ret = g_usbInterface->ClearHalt(dev, pipe); - HDF_LOGI("UsbdClearHalt008 %{public}d ClearHalt=%{public}d",__LINE__, ret); + HDF_LOGI("UsbdClearHalt008 %{public}d ClearHalt=%{public}d", __LINE__, ret); ASSERT_NE(0, ret); } } // USB -- Gitee From a0523aa51476316e9ba8909cd5fe831539bb3947 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 23 Aug 2024 03:47:13 +0000 Subject: [PATCH 0314/1485] =?UTF-8?q?=E5=BA=9F=E5=BC=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 6 ------ usb/ddk/device/src/usbfn_sdk_if.c | 7 +------ usb/ddk/host/src/usb_raw_api_library.c | 6 ------ 3 files changed, 1 insertion(+), 18 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index c6a68d270c..4701dee5e9 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -1289,12 +1289,6 @@ void UsbFnMemFree(const void *mem) } } -int32_t UsbFnAdpMemTestTrigger(bool enable) -{ - g_usbRamTestFlag = enable; - return HDF_SUCCESS; -} - static struct UsbFnAdapterOps g_usbFnAdapter = { .createDevice = UsbFnAdapterCreateDevice, .delDevice = UsbFnAdapterDelDevice, diff --git a/usb/ddk/device/src/usbfn_sdk_if.c b/usb/ddk/device/src/usbfn_sdk_if.c index 9be0c291d9..f3a03f4b66 100644 --- a/usb/ddk/device/src/usbfn_sdk_if.c +++ b/usb/ddk/device/src/usbfn_sdk_if.c @@ -313,9 +313,4 @@ int32_t UsbFnSubmitRequestSync(struct UsbFnRequest *req, uint32_t timeout) return HDF_ERR_INVALID_PARAM; } return UsbFnIoMgrRequestSubmitSync(req, timeout); -} - -int32_t UsbFnMemTestTrigger(bool enable) -{ - return UsbFnAdpMemTestTrigger(enable); -} +} \ No newline at end of file diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 26fb5e1ce2..92fc42948b 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1633,12 +1633,6 @@ void RawRequestListInit(struct UsbDevice *deviceObj) HdfSListInit(&deviceObj->requestList); } -int32_t RawUsbMemTestTrigger(bool enable) -{ - g_usbRamTestFlag = enable; - return HDF_SUCCESS; -} - void *RawUsbMemAlloc(size_t size) { return RawUsbMemCalloc(size); -- Gitee From 47bee8856130f7a489680cc1295e9e9d5b6b04f9 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 23 Aug 2024 06:00:23 +0000 Subject: [PATCH 0315/1485] update usb/ddk/host/src/usb_raw_api_library.c. Signed-off-by: luzhiye --- usb/ddk/host/src/usb_raw_api_library.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 92fc42948b..26fb5e1ce2 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1633,6 +1633,12 @@ void RawRequestListInit(struct UsbDevice *deviceObj) HdfSListInit(&deviceObj->requestList); } +int32_t RawUsbMemTestTrigger(bool enable) +{ + g_usbRamTestFlag = enable; + return HDF_SUCCESS; +} + void *RawUsbMemAlloc(size_t size) { return RawUsbMemCalloc(size); -- Gitee From 2c5f1f5d23b4c3b7b0a4d7827981aa43ec9f6549 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 23 Aug 2024 06:05:23 +0000 Subject: [PATCH 0316/1485] update usb/ddk/device/src/usbfn_sdk_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/usbfn_sdk_if.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/usb/ddk/device/src/usbfn_sdk_if.c b/usb/ddk/device/src/usbfn_sdk_if.c index f3a03f4b66..22fc9cabcd 100644 --- a/usb/ddk/device/src/usbfn_sdk_if.c +++ b/usb/ddk/device/src/usbfn_sdk_if.c @@ -313,4 +313,9 @@ int32_t UsbFnSubmitRequestSync(struct UsbFnRequest *req, uint32_t timeout) return HDF_ERR_INVALID_PARAM; } return UsbFnIoMgrRequestSubmitSync(req, timeout); +} + +int32_t UsbFnMemTestTrigger(bool enable) +{ + return UsbFnAdpMemTestTrigger(enable); } \ No newline at end of file -- Gitee From 18d222db19883084eb3a30b56891e41e8983bada Mon Sep 17 00:00:00 2001 From: luzhiye Date: Fri, 23 Aug 2024 06:06:10 +0000 Subject: [PATCH 0317/1485] update usb/ddk/device/src/adapter_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 4701dee5e9..c6a68d270c 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -1289,6 +1289,12 @@ void UsbFnMemFree(const void *mem) } } +int32_t UsbFnAdpMemTestTrigger(bool enable) +{ + g_usbRamTestFlag = enable; + return HDF_SUCCESS; +} + static struct UsbFnAdapterOps g_usbFnAdapter = { .createDevice = UsbFnAdapterCreateDevice, .delDevice = UsbFnAdapterDelDevice, -- Gitee From 3b3fa9f546ec2d41f2494804e1d930a76fdd0d62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 23 Aug 2024 15:40:12 +0800 Subject: [PATCH 0318/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- light/hal/src/light_controller.c | 1 + 1 file changed, 1 insertion(+) diff --git a/light/hal/src/light_controller.c b/light/hal/src/light_controller.c index d24a3cfa2f..ae6f503abe 100644 --- a/light/hal/src/light_controller.c +++ b/light/hal/src/light_controller.c @@ -294,6 +294,7 @@ static int32_t OnMultiLights(uint32_t lightId, const struct LightColor *colors, sbuf = HdfSbufObtain(sizeof(struct LightColor) * count); if (sbuf == NULL) { HDF_LOGE("%{public}s: sbuf malloc failed", __func__); + (void)OsalMutexUnlock(&priv->mutex); return HDF_DEV_ERR_NO_MEMORY; } -- Gitee From 70c0f17ed7e04a13a265b0995b1acce90368961f Mon Sep 17 00:00:00 2001 From: youshugen Date: Fri, 23 Aug 2024 16:04:35 +0800 Subject: [PATCH 0319/1485] fix: hdi alarming improve Signed-off-by: youshugen --- battery/interfaces/hdi_service/src/power_supply_provider.cpp | 4 ++-- power/interfaces/hdi_service/src/running_lock_impl.cpp | 2 +- thermal/interfaces/hdi_service/src/thermal_zone_manager.cpp | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/battery/interfaces/hdi_service/src/power_supply_provider.cpp b/battery/interfaces/hdi_service/src/power_supply_provider.cpp index 7ee4b2b424..85f9092e3d 100644 --- a/battery/interfaces/hdi_service/src/power_supply_provider.cpp +++ b/battery/interfaces/hdi_service/src/power_supply_provider.cpp @@ -290,7 +290,7 @@ int32_t PowerSupplyProvider::ReadSysfsFile(const char* path, char* buf, size_t s } if (fd != -1) { - size_t readSize = pread(fd, buf, size - 1, 0); + ssize_t readSize = pread(fd, buf, size - 1, 0); buf[readSize] = '\0'; Trim(buf); return HDF_SUCCESS; @@ -302,7 +302,7 @@ int32_t PowerSupplyProvider::ReadSysfsFile(const char* path, char* buf, size_t s return HDF_ERR_IO; } - size_t readSize = read(fd, buf, size - 1); + ssize_t readSize = read(fd, buf, size - 1); buf[readSize] = '\0'; Trim(buf); { diff --git a/power/interfaces/hdi_service/src/running_lock_impl.cpp b/power/interfaces/hdi_service/src/running_lock_impl.cpp index 3c81d1de1e..f6ca893aae 100644 --- a/power/interfaces/hdi_service/src/running_lock_impl.cpp +++ b/power/interfaces/hdi_service/src/running_lock_impl.cpp @@ -150,7 +150,7 @@ void RunningLockImpl::Clean() uint32_t RunningLockImpl::GetCount(RunningLockType type) { std::lock_guard lock(mutex_); - int32_t count = 0; + uint32_t count = 0; auto iterator = lockCounters_.find(type); if (iterator != lockCounters_.end()) { count = iterator->second->GetCount(); diff --git a/thermal/interfaces/hdi_service/src/thermal_zone_manager.cpp b/thermal/interfaces/hdi_service/src/thermal_zone_manager.cpp index 4c75fa46db..4061d7e5d1 100644 --- a/thermal/interfaces/hdi_service/src/thermal_zone_manager.cpp +++ b/thermal/interfaces/hdi_service/src/thermal_zone_manager.cpp @@ -167,9 +167,9 @@ int32_t ThermalZoneManager::GetIntervalCommonDivisor(std::vector interv return NUM_ZERO; } - int32_t count = intervalList.size(); + uint32_t count = intervalList.size(); int32_t commonDivisor = intervalList[0]; - for (int32_t i = 1; i < count; i++) { + for (uint32_t i = 1; i < count; i++) { commonDivisor = ThermalHdfUtils::GetMaxCommonDivisor(commonDivisor, intervalList[i]); } return commonDivisor; -- Gitee From a68a3227b3cb72a5d0f49f8bdbaa858133b20585 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 23 Aug 2024 08:25:35 +0000 Subject: [PATCH 0320/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index e052f1dc88..650d841228 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -104,7 +104,7 @@ WifiError WifiVendorHal::Start() void WifiVendorHal::RunEventLoop() { - pthread_setname_np(pthread_self(), "VendorHalEventThread"); + pthread_setname_np(pthread_self(), "VenEventThread"); HDF_LOGD("Starting vendor HAL event loop"); globalFuncTable_.startHalLoop(globalHandle_); const auto lock = AcquireGlobalLock(); -- Gitee From 230c78f55747a6d3dc2832c103b670fcb36682b6 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 23 Aug 2024 08:48:44 +0000 Subject: [PATCH 0321/1485] update wlan/client/src/netlink/netlink_cmd_adapter.c. Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index 3389d417d4..a5c79ebc30 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -711,7 +711,7 @@ static int32_t WifiMsgRegisterEventListener(void) g_wifiHalInfo.status = THREAD_STOP; return RET_CODE_FAILURE; } - pthread_setname_np(g_wifiHalInfo.thread, "WifiHalEventThread"); + pthread_setname_np(g_wifiHalInfo.thread, "WifiEventThread"); // waiting for thread start running while (g_wifiHalInfo.status != THREAD_RUN) { -- Gitee From 7353e90fa954f97b7000cd79e54d7f30498df8b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 23 Aug 2024 16:59:33 +0800 Subject: [PATCH 0322/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- light/hal/src/light_controller.c | 1 - 1 file changed, 1 deletion(-) diff --git a/light/hal/src/light_controller.c b/light/hal/src/light_controller.c index ae6f503abe..0d04e1d392 100644 --- a/light/hal/src/light_controller.c +++ b/light/hal/src/light_controller.c @@ -293,7 +293,6 @@ static int32_t OnMultiLights(uint32_t lightId, const struct LightColor *colors, sbuf = HdfSbufObtain(sizeof(struct LightColor) * count); if (sbuf == NULL) { - HDF_LOGE("%{public}s: sbuf malloc failed", __func__); (void)OsalMutexUnlock(&priv->mutex); return HDF_DEV_ERR_NO_MEMORY; } -- Gitee From bf56c09caf0e617c7b91280b412dea592cfedd69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Fri, 23 Aug 2024 17:43:14 +0800 Subject: [PATCH 0323/1485] change MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- motion/test/unittest/hdi/BUILD.gn | 2 -- sensor/test/benchmarktest/BUILD.gn | 6 +----- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/motion/test/unittest/hdi/BUILD.gn b/motion/test/unittest/hdi/BUILD.gn index eb4ceed679..b6376c828d 100644 --- a/motion/test/unittest/hdi/BUILD.gn +++ b/motion/test/unittest/hdi/BUILD.gn @@ -11,10 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -HDF_CORE_PATH = "../../../../../hdf_core" import("//build/ohos.gni") import("//build/test.gni") -import("$HDF_CORE_PATH/adapter/uhdf2/uhdf.gni") import("../../../motion.gni") module_output_path = "drivers_peripheral_motion/motion" diff --git a/sensor/test/benchmarktest/BUILD.gn b/sensor/test/benchmarktest/BUILD.gn index 260d1c8375..a387229edf 100644 --- a/sensor/test/benchmarktest/BUILD.gn +++ b/sensor/test/benchmarktest/BUILD.gn @@ -39,16 +39,12 @@ ohos_benchmarktest("hdf_sensor_benchmark_test") { "-fno-strict-aliasing", ] - deps = [ - "//third_party/benchmark", - "//third_party/googletest:gtest_main", - ] - if (is_standard_system) { external_deps = [ "drivers_interface_sensor:libsensor_proxy_2.0", "hdf_core:libhdf_utils", "hilog:libhilog", + "googletest:gtest_main", "ipc:ipc_single", ] if (c_utils_enable) { -- Gitee From 973131bcea029a96ed88f3decd14e8bf331b04bf Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Fri, 23 Aug 2024 18:10:06 +0800 Subject: [PATCH 0324/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=81=E7=9A=84?= =?UTF-8?q?=E4=BD=9C=E7=94=A8=E8=8C=83=E5=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- .../primary_impl/vdi_src/audio_manager_vdi.c | 69 +++++++++++-------- 1 file changed, 40 insertions(+), 29 deletions(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index bb893d726a..975ac88fcf 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -280,17 +280,19 @@ int32_t AudioManagerVendorGetAllAdapters(struct IAudioManager *manager, CHECK_NULL_PTR_RETURN_VALUE(descs, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(descsLen, HDF_ERR_INVALID_PARAM); + pthread_mutex_lock(&g_managerMutex); struct AudioManagerPrivVdi *priv = (struct AudioManagerPrivVdi *)manager; if (priv->vdiManager == NULL) { AUDIO_FUNC_LOGE("audio vdiManager is null"); + pthread_mutex_unlock(&g_managerMutex); return HDF_ERR_INVALID_PARAM; } if (*descsLen > AUDIO_VDI_ADAPTER_NUM_MAX) { AUDIO_FUNC_LOGE("audio adapter num demanded too large"); + pthread_mutex_unlock(&g_managerMutex); return HDF_ERR_INVALID_PARAM; } - pthread_mutex_lock(&g_managerMutex); if (priv->vdiDescsCount != 0 && priv->vdiDescs != NULL && priv->vdiDescsCount >= *descsLen) { int32_t ret = AudioManagerVdiDescsToDescs(priv->vdiDescs, priv->vdiDescsCount, descs, descsLen); if (ret != HDF_SUCCESS) { @@ -329,6 +331,32 @@ static uint32_t AudioManagerVendorFindAdapterPos(struct IAudioManager *manager, return AUDIO_VDI_ADAPTER_NUM_MAX; } +static struct IAudioAdapter* VendorLoadAdapter(struct IAudioManagerVdi *vdiManager, uint32_t &descIndex, + struct AudioAdapterDescriptorVdi &vdiDesc) +{ + int32_t ret = HDF_SUCCESS; + struct IAudioAdapterVdi *vdiAdapter = NULL; + int32_t id = SetTimer("Hdi:LoadAdapter"); + HdfAudioStartTrace("Hdi:AudioManagerVendorLoadAdapter", 0); + ret = vdiManager->LoadAdapter(vdiManager, &vdiDesc, &vdiAdapter); + HdfAudioFinishTrace(); + CancelTimer(id); + + AudioManagerReleaseVdiDesc(&vdiDesc); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("audio vdiManager call LoadAdapter fail, ret=%{public}d", ret); + return NULL; + } + + struct IAudioAdapter *adapter = AudioCreateAdapterVdi(descIndex, vdiAdapter, desc->adapterName); + if (*adapter == NULL) { + AUDIO_FUNC_LOGE("audio vdiManager create adapter fail"); + vdiManager->UnloadAdapter(vdiManager, vdiAdapter); + return NULL; + } + return adapter; +} + int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struct AudioAdapterDescriptor *desc, struct IAudioAdapter **adapter) { @@ -336,11 +364,13 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM); + pthread_mutex_lock(&g_managerMutex); struct AudioManagerPrivVdi *priv = (struct AudioManagerPrivVdi *)manager; - CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager->LoadAdapter, HDF_ERR_INVALID_PARAM); + if (priv == NULL || priv->vdiManager == NULL || priv->vdiManager->LoadAdapter == NULL) { + pthread_mutex_unlock(&g_managerMutex); + return HDF_ERR_INVALID_PARAM; + } - pthread_mutex_lock(&g_managerMutex); uint32_t descIndex = AudioManagerVendorFindAdapterPos(manager, desc->adapterName); if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) { AUDIO_FUNC_LOGE("audio vdiManager find adapter pos"); @@ -365,29 +395,8 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc return HDF_FAILURE; } - struct IAudioAdapterVdi *vdiAdapter = NULL; - int32_t id = SetTimer("Hdi:LoadAdapter"); - HdfAudioStartTrace("Hdi:AudioManagerVendorLoadAdapter", 0); - ret = priv->vdiManager->LoadAdapter(priv->vdiManager, &vdiDesc, &vdiAdapter); - HdfAudioFinishTrace(); - CancelTimer(id); - - AudioManagerReleaseVdiDesc(&vdiDesc); - if (ret != HDF_SUCCESS) { - AUDIO_FUNC_LOGE("audio vdiManager call LoadAdapter fail, ret=%{public}d", ret); - pthread_mutex_unlock(&g_managerMutex); - return HDF_FAILURE; - } - - *adapter = AudioCreateAdapterVdi(descIndex, vdiAdapter, desc->adapterName); - if (*adapter == NULL) { - AUDIO_FUNC_LOGE("audio vdiManager create adapter fail"); - priv->vdiManager->UnloadAdapter(priv->vdiManager, vdiAdapter); - pthread_mutex_unlock(&g_managerMutex); - return HDF_FAILURE; - } + *adapter = VendorLoadAdapter(priv->vdiManager, descIndex, vdiDesc); pthread_mutex_unlock(&g_managerMutex); - AUDIO_FUNC_LOGD("audio vdiManager load vdiAdapter success"); return HDF_SUCCESS; } @@ -397,11 +406,13 @@ static int32_t AudioManagerVendorUnloadAdapter(struct IAudioManager *manager, co CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(adapterName, HDF_ERR_INVALID_PARAM); + pthread_mutex_lock(&g_managerMutex); struct AudioManagerPrivVdi *priv = (struct AudioManagerPrivVdi *)manager; - CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(priv->vdiManager->UnloadAdapter, HDF_ERR_INVALID_PARAM); + if (priv == NULL || priv->vdiManager == NULL || priv->vdiManager->LoadAdapter == NULL) { + pthread_mutex_unlock(&g_managerMutex); + return HDF_ERR_INVALID_PARAM; + } - pthread_mutex_lock(&g_managerMutex); uint32_t descIndex = AudioManagerVendorFindAdapterPos(manager, adapterName); if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) { AUDIO_FUNC_LOGE("AudioManagerVendorUnloadAdapter descIndex error"); -- Gitee From af05b7a5abc66cd216557d150ede88bdfc4f08d5 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Fri, 23 Aug 2024 18:12:44 +0800 Subject: [PATCH 0325/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=81=E7=9A=84?= =?UTF-8?q?=E4=BD=9C=E7=94=A8=E8=8C=83=E5=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index 975ac88fcf..e451765ad8 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -387,7 +387,7 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc } struct AudioAdapterDescriptorVdi vdiDesc = {0}; - int32_t ret = AudioManagerDescToVdiDesc(desc, &vdiDesc); + ret = AudioManagerDescToVdiDesc(desc, &vdiDesc); if (ret != HDF_SUCCESS) { AudioManagerReleaseVdiDesc(&vdiDesc); AUDIO_FUNC_LOGE("audio vdiManager desc To vdiDesc fail, ret=%{public}d", ret); -- Gitee From dc6ab0fddc7d23677654c226873dcb8d92c68321 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Fri, 23 Aug 2024 18:17:17 +0800 Subject: [PATCH 0326/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=81=E7=9A=84?= =?UTF-8?q?=E4=BD=9C=E7=94=A8=E8=8C=83=E5=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index e451765ad8..6c8544be7d 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -396,6 +396,10 @@ int32_t AudioManagerVendorLoadAdapter(struct IAudioManager *manager, const struc } *adapter = VendorLoadAdapter(priv->vdiManager, descIndex, vdiDesc); + if (*adapter == NULL) { + pthread_mutex_unlock(&g_managerMutex); + return HDF_FAILURE; + } pthread_mutex_unlock(&g_managerMutex); AUDIO_FUNC_LOGD("audio vdiManager load vdiAdapter success"); return HDF_SUCCESS; -- Gitee From d57241aaf0c8264adef6bdc120697f9a61ef443f Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 23 Aug 2024 12:57:30 +0000 Subject: [PATCH 0327/1485] update wlan/chip/hdi_service/wifi_vendor_hal.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_vendor_hal.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_vendor_hal.cpp b/wlan/chip/hdi_service/wifi_vendor_hal.cpp index 650d841228..dc593b80e1 100644 --- a/wlan/chip/hdi_service/wifi_vendor_hal.cpp +++ b/wlan/chip/hdi_service/wifi_vendor_hal.cpp @@ -104,7 +104,7 @@ WifiError WifiVendorHal::Start() void WifiVendorHal::RunEventLoop() { - pthread_setname_np(pthread_self(), "VenEventThread"); + pthread_setname_np(pthread_self(), "VendorHalThread"); HDF_LOGD("Starting vendor HAL event loop"); globalFuncTable_.startHalLoop(globalHandle_); const auto lock = AcquireGlobalLock(); -- Gitee From dd037b5891483e7029c9f09916b1462df65b8c8f Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 23 Aug 2024 12:58:24 +0000 Subject: [PATCH 0328/1485] update wlan/client/src/netlink/netlink_cmd_adapter.c. Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index a5c79ebc30..759af9ddea 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -711,7 +711,7 @@ static int32_t WifiMsgRegisterEventListener(void) g_wifiHalInfo.status = THREAD_STOP; return RET_CODE_FAILURE; } - pthread_setname_np(g_wifiHalInfo.thread, "WifiEventThread"); + pthread_setname_np(g_wifiHalInfo.thread, "WifiHalThread"); // waiting for thread start running while (g_wifiHalInfo.status != THREAD_RUN) { -- Gitee From 1448bf217fb0fe10b00e095c50612e092f63814a Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 22 Aug 2024 14:42:09 +0000 Subject: [PATCH 0329/1485] update wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c. Signed-off-by: xionglei --- .../service_common/wpa_common_cmd.c | 332 ++---------------- .../service_common/wpa_common_cmd.h | 10 +- .../service_common/wpa_common_cmd_ext.c | 314 +++++++++++++++++ .../service_common/wpa_common_cmd_ext.h | 31 ++ .../hdi_service/service_common/wpa_p2p_cmd.c | 4 +- 5 files changed, 368 insertions(+), 323 deletions(-) create mode 100644 wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.h diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index e615087fbc..e0cb4dd837 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -39,7 +39,6 @@ #define BUF_SIZE 512 -pthread_t g_tid; const int QUOTATION_MARKS_FLAG_YES = 0; const int QUOTATION_MARKS_FLAG_NO = 1; const int MAX_NETWORKS_NUM = 100; @@ -104,67 +103,6 @@ pthread_mutex_t *GetInterfaceLock() return &g_interfaceLock; } -int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - ScanSettings settings = {0}; - settings.scanStyle = SCAN_TYPE_LOW_SPAN; - int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - if (ret == WIFI_HAL_SCAN_BUSY) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: StartScan return scan busy", __func__); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: StartScan successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, - uint32_t *resultBufLen) -{ - HDF_LOGI("enter %{public}s", __func__); - (void)self; - if (ifName == NULL || resultBuf == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM; - } - pthread_mutex_lock(&g_interfaceLock); - WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); - if (pStaIfc == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); - return HDF_FAILURE; - } - int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); - if (ret < 0) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: Get scan result successfully!", __func__); - return HDF_SUCCESS; -} - int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId) { (void)self; @@ -514,7 +452,7 @@ int32_t WpaInterfaceSetPowerSave(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } -int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) +int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, const int32_t enable) { (void)self; HDF_LOGI("enter %{public}s enable = %{public}d", __func__, enable); @@ -540,22 +478,22 @@ int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } -static bool GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) +static void GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) { if (strcmp(src, "") != 0) { dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); if (dst == NULL) { HDF_LOGE("%{public}s OsalMemCalloc is NULL", __func__); *dstLen = 0; - return FALSE; + return; } *dstLen = strlen(src); if (strcpy_s((char*)dst, strlen(src) + 1, src) != EOK) { HDF_LOGE("%{public}s strcpy failed", __func__); - return FALSE; + return; } } - return TRUE; + return; } static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) @@ -566,14 +504,12 @@ static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWp } status->id = halStatus->id; status->freq = halStatus->freq; - if (GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt) == FALSE) { - HDF_LOGI("%{public}s get status->key_mgmt value=%{private}s failed", __func__, halStatus->keyMgmt); - } - if (GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid) == FALSE) { - HDF_LOGI("%{public}s get status->ssid value=%{private}s failed", __func__, halStatus->keyMgmt); - } + GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt); + GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid); if (strcmp(halStatus->address, "") != 0) { HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); + uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->address, tmpAddress); status->address = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); if (status->address == NULL) { HDF_LOGE("%{public}s status->address is NULL", __func__); @@ -581,10 +517,14 @@ static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWp return; } status->addressLen = ETH_ADDR_LEN + 1 ; - hwaddr_aton(halStatus->address, status->address); + if (memcpy_s((char *)status->address, ETH_ADDR_LEN + 1, (char*)tmpAddress, ETH_ADDR_LEN + 1) != EOK) { + HDF_LOGE("%{public}s strcpy memcpy", __func__); + } } if (strcmp(halStatus->bssid, "") != 0) { HDF_LOGI("%{public}s key include bssid value=%{private}s", __func__, halStatus->bssid); + uint8_t tmpBssid[ETH_ADDR_LEN + 1] = {0}; + hwaddr_aton(halStatus->bssid, tmpBssid); status->bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1)); if (status->bssid == NULL) { HDF_LOGE("%{public}s status->bssid is NULL", __func__); @@ -592,7 +532,9 @@ static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWp return; } status->bssidLen = ETH_ADDR_LEN + 1 ; - hwaddr_aton(halStatus->bssid, status->bssid); + if (strcpy_s((char *)status->bssid, ETH_ADDR_LEN + 1, (char*)tmpBssid) != EOK) { + HDF_LOGE("%{public}s strcpy failed", __func__); + } } } @@ -663,23 +605,6 @@ int32_t WpaInterfaceSaveConfig(struct IWpaInterface *self, const char *ifName) return HDF_SUCCESS; } -static const char *macToStr(const u8 *addr) -{ - const int macAddrIndexOne = 0; - const int macAddrIndexTwo = 1; - const int macAddrIndexThree = 2; - const int macAddrIndexFour = 3; - const int macAddrIndexFive = 4; - const int macAddrIndexSix = 5; - static char macToStr[WIFI_BSSID_LENGTH]; - if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", - addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], - addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { - return NULL; - } - return macToStr; -} - int32_t WpaInterfaceWpsPbcMode(struct IWpaInterface *self, const char *ifName, const struct HdiWifiWpsParam *wpaParam) { HDF_LOGI("enter %{public}s ", __func__); @@ -744,8 +669,8 @@ int32_t WpaInterfaceWpsPinMode(struct IWpaInterface *self, const char *ifName, return HDF_FAILURE; } struct WpaWpsPinArgv config = {{0}, {0}}; - if (strncpy_s(config.bssid, sizeof(config.bssid), macToStr(wpaParam->bssid), - strlen(macToStr(wpaParam->bssid))) != 0) { + if (strncpy_s(config.bssid, sizeof(config.bssid), MacToStr(wpaParam->bssid), + strlen(MacToStr(wpaParam->bssid))) != 0) { pthread_mutex_unlock(&g_interfaceLock); HDF_LOGE("%{public}s: strncpy_s bssid fail", __func__); return HDF_FAILURE; @@ -1667,7 +1592,7 @@ static int32_t WpaFillWpaVendorExtInfo(struct WpaVendorExtInfo *wpaVendorExtInfo HDF_LOGE("%{public}s: wpaVendorExtInfo or wpaVendorInfo is NULL!", __func__); return HDF_ERR_INVALID_PARAM; } - + wpaVendorInfo->data = NULL; wpaVendorInfo->type = wpaVendorExtInfo->type; wpaVendorInfo->freq = wpaVendorExtInfo->freq; wpaVendorInfo->width = wpaVendorExtInfo->width; @@ -1963,223 +1888,6 @@ int32_t WpaInterfaceUnregisterEventCallback(struct IWpaInterface *self, struct I return HDF_SUCCESS; } -static void SplitCmdString(const char *startCmd, struct StWpaMainParam *pParam) -{ - if (pParam == NULL) { - return; - } - if (startCmd == NULL) { - pParam->argc = 0; - return; - } - const char *p = startCmd; - int i = 0; - int j = 0; - while (*p != '\0') { - if (*p == ' ') { - if (j <= MAX_WPA_MAIN_ARGV_LEN - 1) { - pParam->argv[i][j] = '\0'; - } else { - pParam->argv[i][MAX_WPA_MAIN_ARGV_LEN - 1] = '\0'; - } - ++i; - j = 0; - if (i >= MAX_WPA_MAIN_ARGC_NUM) { - break; - } - } else { - if (j < MAX_WPA_MAIN_ARGV_LEN - 1) { - pParam->argv[i][j] = *p; - ++j; - } - } - ++p; - } - if (i >= MAX_WPA_MAIN_ARGC_NUM) { - pParam->argc = MAX_WPA_MAIN_ARGC_NUM; - } else { - pParam->argc = i + 1; - } - return; -} - - -static void *WpaThreadMain(void *p) -{ - const char *startCmd; - struct StWpaMainParam param = {0}; - char *tmpArgv[MAX_WPA_MAIN_ARGC_NUM] = {0}; - - if (p == NULL) { - HDF_LOGE("%{public}s: input parameter invalid!", __func__); - return NULL; - } - startCmd = (const char *)p; - SplitCmdString(startCmd, ¶m); - for (int i = 0; i < param.argc; i++) { - tmpArgv[i] = param.argv[i]; - } - int ret = wpa_main(param.argc, tmpArgv); - HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret); - return NULL; -} - -static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) -{ - int32_t ret; - - if (moduleName == NULL || startCmd == NULL) { - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret); - return HDF_FAILURE; - } - pthread_setname_np(g_tid, "WpaMainThread"); - HDF_LOGI("%{public}s: pthread_create successfully.", __func__); - usleep(WPA_SLEEP_TIME); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { - HDF_LOGE("Failed to connect to wpa!"); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) -{ - (void)self; - if (ifName == NULL || confName == NULL) { - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - HDF_LOGI("enter %{public}s Ready to add iface, ifName: %{public}s, confName: %{public}s", - __func__, ifName, confName); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - AddInterfaceArgv addInterface = {0}; - if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/wpa_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { - if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || - strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, - CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { - return HDF_FAILURE; - } - } else { - HDF_LOGE("%{public}s Wrong ifname!", __func__); - return HDF_FAILURE; - } - if (pWpaInterface->wpaCliAddIface(pWpaInterface, &addInterface, true) < 0) { - HDF_LOGE("%{public}s Failed to add wpa iface!", __func__); - return HDF_FAILURE; - } - HDF_LOGI("%{public}s Add interface finish", __func__); - return HDF_SUCCESS; -} - - -int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName) -{ - (void)self; - HDF_LOGI("enter %{public}s", __func__); - pthread_mutex_lock(&g_interfaceLock); - if (ifName == NULL) { - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGE("%{public}s input parameter invalid!", __func__); - return HDF_ERR_INVALID_PARAM ; - } - HDF_LOGI("enter %{public}s Ready to Remove iface, ifName: %{public}s", __func__, ifName); - int ret = -1; - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("Get wpa interface failed!"); - return HDF_FAILURE; - } - ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); - return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); -} - -static int32_t StopWpaSupplicant(void) -{ - /*Do nothing here,waiting for IWpaInterfaceReleaseInstance to destroy the wpa service. */ - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); - return HDF_FAILURE; - } - int ret = pWpaInterface->wpaCliTerminate(); - if (ret != 0) { - HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); - } else { - HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); - } - return HDF_SUCCESS; -} - -int32_t WpaInterfaceStart(struct IWpaInterface *self) -{ - int32_t ret; - - (void)self; - HDF_LOGI("enter %{public}s: wpa_supplicant begin to start", __func__); - InitWifiWpaGlobalInterface(); - WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); - if (pWpaInterface == NULL) { - HDF_LOGI("fail get global interface"); - return HDF_FAILURE; - } - pthread_mutex_lock(&g_interfaceLock); - ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__); - return HDF_SUCCESS; -} - -int32_t WpaInterfaceStop(struct IWpaInterface *self) -{ - int32_t ret; - - (void)self; - pthread_mutex_lock(&g_interfaceLock); - HDF_LOGI("enter %{public}s: wpa_supplicant begin to stop", __func__); - ret = StopWpaSupplicant(); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret); - pthread_mutex_unlock(&g_interfaceLock); - return HDF_FAILURE; - } - ReleaseWifiStaInterface(0); - pthread_mutex_unlock(&g_interfaceLock); - HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); - return HDF_SUCCESS; -} - int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName) { (void)self; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h index 4c4336986e..4a21305793 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.h @@ -21,6 +21,7 @@ #include "utils/common.h" #include "wpa_supplicant_hal.h" #include "wpa_client.h" +#include "wpa_common_cmd_ext.h" #define WIFI_SSID_LENGTH 132 #define WIFI_BSSID_LENGTH 18 @@ -53,13 +54,6 @@ #define WIFI_NETWORK_CONFIG_VALUE_LENGTH 2048 #define CMD_LEN 6 -int32_t WpaInterfaceStart(struct IWpaInterface *self); -int32_t WpaInterfaceStop(struct IWpaInterface *self); -int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) ; -int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName); -int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName); -int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, - uint32_t *resultBufLen); int32_t WpaInterfaceAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId); int32_t WpaInterfaceRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId); int32_t WpaInterfaceDisableNetwork(struct IWpaInterface *self, const char *ifName, const int32_t networkId); @@ -110,11 +104,9 @@ int32_t WpaInterfaceReassociate(struct IWpaInterface *self, const char *ifName); int32_t WpaInterfaceStaShellCmd(struct IWpaInterface *self, const char *ifName, const char *cmd); void HdfWpaDelRemoteObj(struct IWpaCallback *self); - int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen); pthread_mutex_t *GetInterfaceLock(); -const char *macToStr(const u8 *addr); struct StWpaMainParam { int argc; char argv[MAX_WPA_MAIN_ARGC_NUM][MAX_WPA_MAIN_ARGV_LEN]; diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index badf1cc59a..6d2b8f74d2 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -38,6 +38,87 @@ #include #include "hdi_wpa_common.h" +pthread_t g_tid; +#define MAX_WPA_WAIT_TIMES 30 + +static void SplitCmdString(const char *startCmd, struct StWpaMainParam *pParam) +{ + if (pParam == NULL) { + return; + } + if (startCmd == NULL) { + pParam->argc = 0; + return; + } + const char *p = startCmd; + int i = 0; + int j = 0; + while (*p != '\0') { + if (*p == ' ') { + if (j <= MAX_WPA_MAIN_ARGV_LEN - 1) { + pParam->argv[i][j] = '\0'; + } else { + pParam->argv[i][MAX_WPA_MAIN_ARGV_LEN - 1] = '\0'; + } + ++i; + j = 0; + if (i >= MAX_WPA_MAIN_ARGC_NUM) { + break; + } + } else { + if (j < MAX_WPA_MAIN_ARGV_LEN - 1) { + pParam->argv[i][j] = *p; + ++j; + } + } + ++p; + } + if (i >= MAX_WPA_MAIN_ARGC_NUM) { + pParam->argc = MAX_WPA_MAIN_ARGC_NUM; + } else { + pParam->argc = i + 1; + } + return; +} + +static void *WpaThreadMain(void *p) +{ + const char *startCmd; + struct StWpaMainParam param = {0}; + char *tmpArgv[MAX_WPA_MAIN_ARGC_NUM] = {0}; + + if (p == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return NULL; + } + startCmd = (const char *)p; + SplitCmdString(startCmd, ¶m); + for (int i = 0; i < param.argc; i++) { + tmpArgv[i] = param.argv[i]; + } + int ret = wpa_main(param.argc, tmpArgv); + HDF_LOGI("%{public}s: run wpa_main ret:%{public}d.", __func__, ret); + g_tid = 0; + return NULL; +} + +const char *MacToStr(const u8 *addr) +{ + const int macAddrIndexOne = 0; + const int macAddrIndexTwo = 1; + const int macAddrIndexThree = 2; + const int macAddrIndexFour = 3; + const int macAddrIndexFive = 4; + const int macAddrIndexSix = 5; + static char macToStr[WIFI_BSSID_LENGTH]; + if (snprintf_s(macToStr, sizeof(macToStr), sizeof(macToStr)-1, "%02x:%02x:%02x:%02x:%02x:%02x", + addr[macAddrIndexOne], addr[macAddrIndexTwo], addr[macAddrIndexThree], addr[macAddrIndexFour], + addr[macAddrIndexFive], addr[macAddrIndexSix]) < 0) { + return NULL; + } + return macToStr; +} + int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) { if (src == NULL || dst == NULL || dstLen == NULL) { @@ -53,6 +134,8 @@ int32_t FillData(uint8_t **dst, uint32_t *dstLen, uint8_t *src, uint32_t srcLen) } if (memcpy_s(*dst, srcLen, src, srcLen) != EOK) { HDF_LOGE("%{public}s: memcpy_s fail!", __func__); + OsalMemFree(*dst); + *dst = NULL; return HDF_FAILURE; } } @@ -83,3 +166,234 @@ void HdfWpaDelRemoteObj(struct IWpaCallback *self) } IWpaCallbackRelease(self); } + +static int32_t StartWpaSupplicant(const char *moduleName, const char *startCmd) +{ + int32_t ret; + int32_t times = 0; + + if (moduleName == NULL || startCmd == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + while (g_tid != 0) { + HDF_LOGI("%{public}s: wpa_supplicant is already running!", __func__); + usleep(WPA_SLEEP_TIME); + times++; + if (times > MAX_WPA_WAIT_TIMES) { + HDF_LOGE("%{public}s: wait supplicant time out!", __func__); + return HDF_FAILURE; + } + } + ret = pthread_create(&g_tid, NULL, WpaThreadMain, (void *)startCmd); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Create wpa thread failed, error code: %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_setname_np(g_tid, "WpaMainThread"); + HDF_LOGI("%{public}s: pthread_create successfully.", __func__); + usleep(WPA_SLEEP_TIME); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + return HDF_FAILURE; + } + if (pWpaInterface->wpaCliConnect(pWpaInterface) < 0) { + HDF_LOGE("Failed to connect to wpa!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t WpaInterfaceStart(struct IWpaInterface *self) +{ + int32_t ret; + + (void)self; + HDF_LOGI("enter %{public}s: wpa_supplicant begin to start", __func__); + InitWifiWpaGlobalInterface(); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGI("fail get global interface"); + return HDF_FAILURE; + } + pthread_mutex_lock(GetInterfaceLock()); + ret = StartWpaSupplicant(WPA_SUPPLICANT_NAME, START_CMD); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: StartWpaSupplicant failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s: wpa_supplicant start successfully!", __func__); + return HDF_SUCCESS; +} + +static int32_t StopWpaSupplicant(void) +{ + /*Do nothing here,waiting for IWpaInterfaceReleaseInstance to destroy the wpa service. */ + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("%{public}s: Get wpa global interface failed!", __func__); + return HDF_FAILURE; + } + int ret = pWpaInterface->wpaCliTerminate(); + if (ret != 0) { + HDF_LOGE("%{public}s: wpaCliTerminate failed!", __func__); + } else { + HDF_LOGI("%{public}s: wpaCliTerminate suc!", __func__); + } + return HDF_SUCCESS; +} + +int32_t WpaInterfaceStop(struct IWpaInterface *self) +{ + int32_t ret; + + (void)self; + pthread_mutex_lock(GetInterfaceLock()); + HDF_LOGI("enter %{public}s: wpa_supplicant begin to stop", __func__); + ret = StopWpaSupplicant(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: Wifi stop failed, error code: %{public}d", __func__, ret); + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + ReleaseWifiStaInterface(0); + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) +{ + (void)self; + if (ifName == NULL || confName == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + HDF_LOGI("enter %{public}s Ready to add iface, ifName: %{public}s, confName: %{public}s", + __func__, ifName, confName); + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + AddInterfaceArgv addInterface = {0}; + if (strncmp(ifName, "wlan", strlen("wlan")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/wpa_supplicant.conf") != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + } else if (strncmp(ifName, "chba0", strlen("chba0")) == 0) { + if (strcpy_s(addInterface.name, sizeof(addInterface.name) - 1, ifName) != EOK || + strcpy_s(addInterface.confName, sizeof(addInterface.confName) - 1, + CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != EOK) { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + } else { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + if (pWpaInterface->wpaCliAddIface(pWpaInterface, &addInterface, true) < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s Add interface finish", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM ; + } + HDF_LOGI("enter %{public}s Ready to Remove iface, ifName: %{public}s", __func__, ifName); + int ret = -1; + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaInterface *pWpaInterface = GetWifiWpaGlobalInterface(); + if (pWpaInterface == NULL) { + HDF_LOGE("Get wpa interface failed!"); + pthread_mutex_unlock(GetInterfaceLock()); + return HDF_FAILURE; + } + ret = pWpaInterface->wpaCliRemoveIface(pWpaInterface, ifName); + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s Remove wpa iface finish, ifName: %{public}s ret = %{public}d", __func__, ifName, ret); + return (ret == 0 ? HDF_SUCCESS : HDF_FAILURE); +} + +int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName) +{ + (void)self; + HDF_LOGI("enter %{public}s", __func__); + if (ifName == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + ScanSettings settings = {0}; + settings.scanStyle = SCAN_TYPE_LOW_SPAN; + int ret = pStaIfc->wpaCliCmdScan(pStaIfc, &settings); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: StartScan fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + if (ret == WIFI_HAL_SCAN_BUSY) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: StartScan return scan busy", __func__); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s: StartScan successfully!", __func__); + return HDF_SUCCESS; +} + +int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, + uint32_t *resultBufLen) +{ + HDF_LOGI("enter %{public}s", __func__); + (void)self; + if (ifName == NULL || resultBuf == NULL) { + HDF_LOGE("%{public}s: input parameter invalid!", __func__); + return HDF_ERR_INVALID_PARAM; + } + pthread_mutex_lock(GetInterfaceLock()); + WifiWpaStaInterface *pStaIfc = GetWifiStaInterface(ifName); + if (pStaIfc == NULL) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: pStaIfc = NULL", __func__); + return HDF_FAILURE; + } + int ret = pStaIfc->wpaCliCmdScanInfo(pStaIfc, resultBuf, resultBufLen); + if (ret < 0) { + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGE("%{public}s: WpaCliCmdScanInfo2 fail! ret = %{public}d", __func__, ret); + return HDF_FAILURE; + } + pthread_mutex_unlock(GetInterfaceLock()); + HDF_LOGI("%{public}s: Get scan result successfully!", __func__); + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.h b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.h new file mode 100644 index 0000000000..67018140f9 --- /dev/null +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef WPA_COMMON_CMD_EXT_H +#define WPA_COMMON_CMD_EXT_H + +#include "../wpa_impl.h" +#include +#include "utils/common.h" +#include "wpa_supplicant_hal.h" + +int32_t WpaInterfaceStart(struct IWpaInterface *self); +int32_t WpaInterfaceStop(struct IWpaInterface *self); +int32_t WpaInterfaceAddWpaIface(struct IWpaInterface *self, const char *ifName, const char *confName) ; +int32_t WpaInterfaceRemoveWpaIface(struct IWpaInterface *self, const char *ifName); +int32_t WpaInterfaceScan(struct IWpaInterface *self, const char *ifName); +int32_t WpaInterfaceScanResult(struct IWpaInterface *self, const char *ifName, unsigned char *resultBuf, + uint32_t *resultBufLen); +const char *MacToStr(const u8 *addr); +#endif diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c index 88d79531d0..4931693543 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_p2p_cmd.c @@ -1035,7 +1035,7 @@ int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, c char persistent[CMD_SIZE] = {0}; if (info->peerDevAddr && strlen(peerDevAddr) >= MIN_MAC_LEN) { ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_CONNECT %s %s%s%s%s", ifName, - macToStr(info->peerDevAddr), pin, mode, persistent, join); + MacToStr(info->peerDevAddr), pin, mode, persistent, join); } if (ret < 0) { pthread_mutex_unlock(GetInterfaceLock()); @@ -1091,7 +1091,7 @@ int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifNa } HDF_LOGI("hid2dconnect freq=%{public}d, isLegacyGo=%{public}d", freq, isLegacyGo); if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s MAGICLINK \"%s\"\n%s\n\"%s\"\n%d\n%d", ifName, - (char *)info->ssid, macToStr(info->bssid), (char *)info->passphrase, freq, isLegacyGo) < 0) { + (char *)info->ssid, MacToStr(info->bssid), (char *)info->passphrase, freq, isLegacyGo) < 0) { pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGE("%{public}s snprintf_s failed, cmd: %{private}s.", __func__, cmd); return HDF_FAILURE; -- Gitee From a7b98b5718fb486330d18e72baab1509e2186b5e Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 08:41:08 +0800 Subject: [PATCH 0330/1485] =?UTF-8?q?=E8=8A=AF=E7=89=87=E7=BB=84=E4=BB=B6?= =?UTF-8?q?=E7=BC=96=E8=AF=91=E4=BE=9D=E8=B5=96=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: hechaofan --- usb/BUILD.gn | 2 +- usb/ddk/BUILD.gn | 6 +++--- usb/ddk_service/BUILD.gn | 2 +- usb/gadget/function/acm/BUILD.gn | 2 +- usb/gadget/function/ecm/BUILD.gn | 2 +- usb/gadget/function/mtp/BUILD.gn | 2 +- usb/gadget/function/usbfn/BUILD.gn | 2 +- usb/hdi_service/BUILD.gn | 2 +- usb/net/BUILD.gn | 2 +- usb/serial/BUILD.gn | 6 +++--- usb/test/unittest/hal/BUILD.gn | 14 +++++++------- usb/test/unittest/mock/BUILD.gn | 17 ++++++++--------- 12 files changed, 29 insertions(+), 30 deletions(-) diff --git a/usb/BUILD.gn b/usb/BUILD.gn index 1e8bf96cbe..3e3ffadf91 100644 --- a/usb/BUILD.gn +++ b/usb/BUILD.gn @@ -17,7 +17,7 @@ if (defined(ohos_lite)) { } } else { import("//build/ohos.gni") - import("./../../hdf_core/adapter/uhdf2/uhdf.gni") + import("//build/config/components/hdi/hdi.gni") group("usb_entry") { deps = [ diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index ba1e5368da..64efd8e919 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../usb.gni") group("libusb_core") { @@ -36,13 +36,13 @@ ohos_shared_library("libusb_ddk_host") { include_dirs = [ "device/include", - "$hdf_framework_path/model/usb/include", "host/include", "./../interfaces/ddk/common", "./../interfaces/ddk/device", "./../interfaces/ddk/host", "./../utils/include", ] + public_external_deps = [ "hdf_core:libhdf_usb" ] sources = [ "host/src/linux_adapter.c", "host/src/usb_interface_pool.c", @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + public_external_deps = [ "hdf_core:libhdf_usb" ] } ohos_shared_library("libusb_pnp_manager") { diff --git a/usb/ddk_service/BUILD.gn b/usb/ddk_service/BUILD.gn index 466c0a655a..78d3f69a97 100644 --- a/usb/ddk_service/BUILD.gn +++ b/usb/ddk_service/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../usb.gni") config("ddk_public_config") { diff --git a/usb/gadget/function/acm/BUILD.gn b/usb/gadget/function/acm/BUILD.gn index 338c779baf..28c9e10c42 100644 --- a/usb/gadget/function/acm/BUILD.gn +++ b/usb/gadget/function/acm/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../../../usb.gni") group("usbfn_cdcacm") { diff --git a/usb/gadget/function/ecm/BUILD.gn b/usb/gadget/function/ecm/BUILD.gn index dff9c857e3..48aab86f06 100644 --- a/usb/gadget/function/ecm/BUILD.gn +++ b/usb/gadget/function/ecm/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../../../usb.gni") group("usbfn_cdcecm") { diff --git a/usb/gadget/function/mtp/BUILD.gn b/usb/gadget/function/mtp/BUILD.gn index cf5397ef8c..2ab643bcbb 100644 --- a/usb/gadget/function/mtp/BUILD.gn +++ b/usb/gadget/function/mtp/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../../../usb.gni") ohos_shared_library("libusbfn_mtp_interface_service_1.0") { diff --git a/usb/gadget/function/usbfn/BUILD.gn b/usb/gadget/function/usbfn/BUILD.gn index c8ba4d1a86..9c2628cf94 100644 --- a/usb/gadget/function/usbfn/BUILD.gn +++ b/usb/gadget/function/usbfn/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../../../usb.gni") group("usbfn") { diff --git a/usb/hdi_service/BUILD.gn b/usb/hdi_service/BUILD.gn index dfeb80b7eb..2cc210332b 100644 --- a/usb/hdi_service/BUILD.gn +++ b/usb/hdi_service/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../usb.gni") config("usbd_private_config") { diff --git a/usb/net/BUILD.gn b/usb/net/BUILD.gn index 4201664805..4e9f89f447 100644 --- a/usb/net/BUILD.gn +++ b/usb/net/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../usb.gni") group("usbhost_ecm") { deps = [ ":libusbhost_ecm" ] diff --git a/usb/serial/BUILD.gn b/usb/serial/BUILD.gn index ccee2855e7..058f2ba9b1 100644 --- a/usb/serial/BUILD.gn +++ b/usb/serial/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//build/ohos.gni") -import("./../../../hdf_core/adapter/uhdf2/uhdf.gni") +import("//build/config/components/hdi/hdi.gni") import("./../usb.gni") group("usbhost_acm") { deps = [ ":libusbhost_acm" ] @@ -37,7 +37,6 @@ ohos_shared_library("libusbhost_acm") { "./../interfaces/ddk/common", "./../interfaces/ddk/host", "./../gadget/function/include", - "./../../../hdf_core/framework/model/usb/include", "include", "${usb_driver_path}/utils/include", ] @@ -47,6 +46,7 @@ ohos_shared_library("libusbhost_acm") { if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", + "hdf_core:libhdf_usb", "hdf_core:libhdf_utils", "hilog:libhilog", ] @@ -83,7 +83,6 @@ ohos_shared_library("libusbhost_acm_rawapi") { "./../gadget/function/include", "./../interfaces/ddk/common", "./../interfaces/ddk/host", - "./../../../hdf_core/framework/model/usb/include", "include", "${usb_driver_path}/utils/include", ] @@ -93,6 +92,7 @@ ohos_shared_library("libusbhost_acm_rawapi") { if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", + "hdf_core:libhdf_usb", "hdf_core:libhdf_utils", "hilog:libhilog", ] diff --git a/usb/test/unittest/hal/BUILD.gn b/usb/test/unittest/hal/BUILD.gn index 5df444e0ee..5c0ee26aea 100644 --- a/usb/test/unittest/hal/BUILD.gn +++ b/usb/test/unittest/hal/BUILD.gn @@ -39,13 +39,13 @@ ohos_unittest("test_transfer") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -86,13 +86,13 @@ ohos_unittest("test_device") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -126,13 +126,13 @@ ohos_unittest("test_function") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", @@ -176,13 +176,13 @@ ohos_unittest("test_request") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -217,7 +217,6 @@ ohos_unittest("test_usbfnmtp") { "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/gadget/function/mtp:libusbfn_mtp_interface_service_1.0", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { @@ -225,6 +224,7 @@ ohos_unittest("test_usbfnmtp") { "drivers_interface_usb:libusb_proxy_1.1", "drivers_interface_usb:libusbfn_mtp_proxy_1.0", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_host", "hdf_core:libhdf_utils", "hilog:libhilog", @@ -252,13 +252,13 @@ ohos_unittest("test_manageinterface") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -297,13 +297,13 @@ ohos_unittest("test_devicestatus") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gtest_main", ] if (is_standard_system) { external_deps = [ "drivers_interface_usb:libusb_proxy_1.1", "eventhandler:libeventhandler", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", diff --git a/usb/test/unittest/mock/BUILD.gn b/usb/test/unittest/mock/BUILD.gn index 73e5f2fcbc..e41f9c943a 100644 --- a/usb/test/unittest/mock/BUILD.gn +++ b/usb/test/unittest/mock/BUILD.gn @@ -24,7 +24,6 @@ config("module_private_config") { "./../../../hdi_service/include", "./../../../ddk/host/include", "./../../../gadget/function/include", - "//third_party/googletest/googlemock/include", "${usb_driver_path}/test/UsbSubscriberTest", "${usb_driver_path}/utils/include", ] @@ -41,14 +40,14 @@ ohos_unittest("transfer_auto_test") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", "drivers_interface_usb:libusb_proxy_1.0", "eventhandler:libeventhandler", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -75,14 +74,14 @@ ohos_unittest("device_auto_test") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", "drivers_interface_usb:libusb_proxy_1.0", "eventhandler:libeventhandler", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -103,14 +102,14 @@ ohos_unittest("request_auto_test") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", "drivers_interface_usb:libusb_proxy_1.0", "eventhandler:libeventhandler", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", @@ -128,14 +127,14 @@ ohos_unittest("function_auto_test") { deps = [ "${usb_driver_path}/ddk:libusb_core", "${usb_driver_path}/hdi_service:libusb_interface_service_1.1", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", ] external_deps = [ "c_utils:utils", "drivers_interface_usb:libusb_proxy_1.0", "eventhandler:libeventhandler", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", "ipc:ipc_single", -- Gitee From 2844f1a121fb1a3ef8189008ed9dce098980b554 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:43:19 +0000 Subject: [PATCH 0331/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index 64efd8e919..7ae61906f1 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -37,12 +37,12 @@ ohos_shared_library("libusb_ddk_host") { include_dirs = [ "device/include", "host/include", + "$hdf_framework_path/model/usb/include", "./../interfaces/ddk/common", "./../interfaces/ddk/device", "./../interfaces/ddk/host", "./../utils/include", ] - public_external_deps = [ "hdf_core:libhdf_usb" ] sources = [ "host/src/linux_adapter.c", "host/src/usb_interface_pool.c", -- Gitee From 020ea1b2009175937b62d18742e5b501904a7a6c Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:44:00 +0000 Subject: [PATCH 0332/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index 7ae61906f1..e840f27a3b 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -36,8 +36,8 @@ ohos_shared_library("libusb_ddk_host") { include_dirs = [ "device/include", - "host/include", "$hdf_framework_path/model/usb/include", + "host/include", "./../interfaces/ddk/common", "./../interfaces/ddk/device", "./../interfaces/ddk/host", @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - public_external_deps = [ "hdf_core:libhdf_usb" ] + include_dirs = [ "$hdf_framework_path/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { -- Gitee From 0be9ccb6944dc991a23f5d8cc78887021bf160ed Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:44:31 +0000 Subject: [PATCH 0333/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index e840f27a3b..a6221e3402 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + include_dirs = [ "$hdf_framework_path/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { -- Gitee From 0783ab54b31e02acb408e6ab6cadbf0b0e88d0e6 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:45:48 +0000 Subject: [PATCH 0334/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index a6221e3402..e840f27a3b 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + include_dirs = [ "$hdf_framework_path/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { -- Gitee From af2d6e6ae0bcd9e2ed145a534a6c17a1215f36d9 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:46:36 +0000 Subject: [PATCH 0335/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index e840f27a3b..a6221e3402 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + include_dirs = [ "$hdf_framework_path/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { -- Gitee From cf3c74716f1dbcaca8a54b7e8d9fde74f11b37d6 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:47:12 +0000 Subject: [PATCH 0336/1485] update usb/ddk/BUILD.gn. Signed-off-by: hechaofan --- usb/ddk/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index a6221e3402..73c2b95524 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + include_dirs = [ "$hdf_framework_path/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { -- Gitee From 2ce55a487ed2696d5383c7f42597dcc849879f32 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:48:08 +0000 Subject: [PATCH 0337/1485] update usb/serial/BUILD.gn. Signed-off-by: hechaofan --- usb/serial/BUILD.gn | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/usb/serial/BUILD.gn b/usb/serial/BUILD.gn index 058f2ba9b1..e00e7f9cc1 100644 --- a/usb/serial/BUILD.gn +++ b/usb/serial/BUILD.gn @@ -37,12 +37,11 @@ ohos_shared_library("libusbhost_acm") { "./../interfaces/ddk/common", "./../interfaces/ddk/host", "./../gadget/function/include", + "./../../../hdf_core/framework/model/usb/include", "include", "${usb_driver_path}/utils/include", ] - deps = [ "./../ddk:libusb_ddk_host" ] - if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", @@ -83,12 +82,11 @@ ohos_shared_library("libusbhost_acm_rawapi") { "./../gadget/function/include", "./../interfaces/ddk/common", "./../interfaces/ddk/host", + "./../../../hdf_core/framework/model/usb/include", "include", "${usb_driver_path}/utils/include", ] - deps = [ "./../ddk:libusb_ddk_host" ] - if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", -- Gitee From 5c112dbe7b83144d387aa5a8e6a6170ebc9b9db0 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:49:32 +0000 Subject: [PATCH 0338/1485] update usb/serial/BUILD.gn. Signed-off-by: hechaofan --- usb/serial/BUILD.gn | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/usb/serial/BUILD.gn b/usb/serial/BUILD.gn index e00e7f9cc1..0be3e71870 100644 --- a/usb/serial/BUILD.gn +++ b/usb/serial/BUILD.gn @@ -41,11 +41,12 @@ ohos_shared_library("libusbhost_acm") { "include", "${usb_driver_path}/utils/include", ] + + deps = [ "./../ddk:libusb_ddk_host" ] if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", - "hdf_core:libhdf_usb", "hdf_core:libhdf_utils", "hilog:libhilog", ] @@ -87,10 +88,11 @@ ohos_shared_library("libusbhost_acm_rawapi") { "${usb_driver_path}/utils/include", ] + deps = [ "./../ddk:libusb_ddk_host" ] + if (is_standard_system) { external_deps = [ "hdf_core:libhdf_host", - "hdf_core:libhdf_usb", "hdf_core:libhdf_utils", "hilog:libhilog", ] -- Gitee From 9a32dba2494e6fbf7ee9a9f46a95b97a499c69d3 Mon Sep 17 00:00:00 2001 From: hechaofan Date: Sat, 24 Aug 2024 00:50:00 +0000 Subject: [PATCH 0339/1485] update usb/serial/BUILD.gn. Signed-off-by: hechaofan --- usb/BUILD.gn | 2 +- usb/ddk/BUILD.gn | 10 +++++----- usb/ddk_service/BUILD.gn | 4 ++-- usb/gadget/function/acm/BUILD.gn | 2 +- usb/gadget/function/ecm/BUILD.gn | 2 +- usb/gadget/function/mtp/BUILD.gn | 2 +- usb/gadget/function/usbfn/BUILD.gn | 2 +- usb/hdi_service/BUILD.gn | 2 +- usb/net/BUILD.gn | 4 ++-- usb/serial/BUILD.gn | 4 ++-- 10 files changed, 17 insertions(+), 17 deletions(-) diff --git a/usb/BUILD.gn b/usb/BUILD.gn index 3e3ffadf91..eccbd5f32a 100644 --- a/usb/BUILD.gn +++ b/usb/BUILD.gn @@ -16,8 +16,8 @@ if (defined(ohos_lite)) { deps = [] } } else { - import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") + import("//build/ohos.gni") group("usb_entry") { deps = [ diff --git a/usb/ddk/BUILD.gn b/usb/ddk/BUILD.gn index 73c2b95524..4c0a02155e 100644 --- a/usb/ddk/BUILD.gn +++ b/usb/ddk/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../usb.gni") group("libusb_core") { @@ -36,7 +36,7 @@ ohos_shared_library("libusb_ddk_host") { include_dirs = [ "device/include", - "$hdf_framework_path/model/usb/include", + "//drivers/hdf_core/framework/model/usb/include", "host/include", "./../interfaces/ddk/common", "./../interfaces/ddk/device", @@ -80,7 +80,7 @@ ohos_shared_library("libusb_ddk_host") { } config("public_headers") { - include_dirs = [ "$hdf_framework_path/model/usb/include" ] + include_dirs = [ "//drivers/hdf_core/framework/model/usb/include" ] } ohos_shared_library("libusb_pnp_manager") { @@ -101,8 +101,8 @@ ohos_shared_library("libusb_pnp_manager") { ] public_configs = [ ":public_headers" ] sources = [ - "$hdf_framework_path/model/usb/src/usb_ddk_pnp_loader.c", - "$hdf_framework_path/model/usb/src/usb_wrapper.cpp", + "//drivers/hdf_core/framework/model/usb/src/usb_ddk_pnp_loader.c", + "//drivers/hdf_core/framework/model/usb/src/usb_wrapper.cpp", "device/src/usbfn_uevent_handle.c", "host/src/ddk_device_manager.c", "host/src/ddk_pnp_listener_mgr.c", diff --git a/usb/ddk_service/BUILD.gn b/usb/ddk_service/BUILD.gn index 78d3f69a97..2659975547 100644 --- a/usb/ddk_service/BUILD.gn +++ b/usb/ddk_service/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../usb.gni") config("ddk_public_config") { @@ -43,7 +43,7 @@ ohos_shared_library("libusb_ddk_service_1.0") { "${usb_driver_path}/interfaces/ddk/host", "${usb_driver_path}/interfaces/ddk/common", "${usb_driver_path}/ddk/host/include", - "${hdf_framework_path}/model/usb/include", + "//drivers/hdf_core/framework/model/usb/include", "${usb_driver_path}/utils/include", ] diff --git a/usb/gadget/function/acm/BUILD.gn b/usb/gadget/function/acm/BUILD.gn index 28c9e10c42..eb822d67c7 100644 --- a/usb/gadget/function/acm/BUILD.gn +++ b/usb/gadget/function/acm/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../../../usb.gni") group("usbfn_cdcacm") { diff --git a/usb/gadget/function/ecm/BUILD.gn b/usb/gadget/function/ecm/BUILD.gn index 48aab86f06..8103d30b9f 100644 --- a/usb/gadget/function/ecm/BUILD.gn +++ b/usb/gadget/function/ecm/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../../../usb.gni") group("usbfn_cdcecm") { diff --git a/usb/gadget/function/mtp/BUILD.gn b/usb/gadget/function/mtp/BUILD.gn index 2ab643bcbb..62c86bb2c6 100644 --- a/usb/gadget/function/mtp/BUILD.gn +++ b/usb/gadget/function/mtp/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../../../usb.gni") ohos_shared_library("libusbfn_mtp_interface_service_1.0") { diff --git a/usb/gadget/function/usbfn/BUILD.gn b/usb/gadget/function/usbfn/BUILD.gn index 9c2628cf94..09fbec966c 100644 --- a/usb/gadget/function/usbfn/BUILD.gn +++ b/usb/gadget/function/usbfn/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../../../usb.gni") group("usbfn") { diff --git a/usb/hdi_service/BUILD.gn b/usb/hdi_service/BUILD.gn index 2cc210332b..63cab792d2 100644 --- a/usb/hdi_service/BUILD.gn +++ b/usb/hdi_service/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../usb.gni") config("usbd_private_config") { diff --git a/usb/net/BUILD.gn b/usb/net/BUILD.gn index 4e9f89f447..4033833114 100644 --- a/usb/net/BUILD.gn +++ b/usb/net/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../usb.gni") group("usbhost_ecm") { deps = [ ":libusbhost_ecm" ] @@ -37,7 +37,7 @@ ohos_shared_library("libusbhost_ecm") { "./../interfaces/ddk/common", "./../interfaces/ddk/host", "./../gadget/function/include", - "${hdf_framework_path}/model/usb/include", + "//drivers/hdf_core/framework/model/usb/include", "include", "${usb_driver_path}/utils/include", ] diff --git a/usb/serial/BUILD.gn b/usb/serial/BUILD.gn index 0be3e71870..849a917dcf 100644 --- a/usb/serial/BUILD.gn +++ b/usb/serial/BUILD.gn @@ -11,8 +11,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") import("./../usb.gni") group("usbhost_acm") { deps = [ ":libusbhost_acm" ] @@ -41,7 +41,7 @@ ohos_shared_library("libusbhost_acm") { "include", "${usb_driver_path}/utils/include", ] - + deps = [ "./../ddk:libusb_ddk_host" ] if (is_standard_system) { -- Gitee From 543e67495c19a0ad7fdf00f9f2637d675fed4046 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 24 Aug 2024 10:16:11 +0800 Subject: [PATCH 0340/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/test/benchmarktest/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/test/benchmarktest/BUILD.gn b/sensor/test/benchmarktest/BUILD.gn index a387229edf..b6bec299a6 100644 --- a/sensor/test/benchmarktest/BUILD.gn +++ b/sensor/test/benchmarktest/BUILD.gn @@ -42,9 +42,9 @@ ohos_benchmarktest("hdf_sensor_benchmark_test") { if (is_standard_system) { external_deps = [ "drivers_interface_sensor:libsensor_proxy_2.0", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", - "googletest:gtest_main", "ipc:ipc_single", ] if (c_utils_enable) { -- Gitee From 28a309c41423b62c97be360672e85d7eb3a39a08 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 02:28:36 +0000 Subject: [PATCH 0341/1485] =?UTF-8?q?=E5=BA=9F=E5=BC=83=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 6 ------ usb/ddk/device/src/usbfn_sdk_if.c | 5 ----- usb/ddk/host/src/usb_raw_api_library.c | 6 ------ 3 files changed, 17 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index c6a68d270c..4701dee5e9 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -1289,12 +1289,6 @@ void UsbFnMemFree(const void *mem) } } -int32_t UsbFnAdpMemTestTrigger(bool enable) -{ - g_usbRamTestFlag = enable; - return HDF_SUCCESS; -} - static struct UsbFnAdapterOps g_usbFnAdapter = { .createDevice = UsbFnAdapterCreateDevice, .delDevice = UsbFnAdapterDelDevice, diff --git a/usb/ddk/device/src/usbfn_sdk_if.c b/usb/ddk/device/src/usbfn_sdk_if.c index 22fc9cabcd..9dc690d826 100644 --- a/usb/ddk/device/src/usbfn_sdk_if.c +++ b/usb/ddk/device/src/usbfn_sdk_if.c @@ -314,8 +314,3 @@ int32_t UsbFnSubmitRequestSync(struct UsbFnRequest *req, uint32_t timeout) } return UsbFnIoMgrRequestSubmitSync(req, timeout); } - -int32_t UsbFnMemTestTrigger(bool enable) -{ - return UsbFnAdpMemTestTrigger(enable); -} \ No newline at end of file diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 26fb5e1ce2..92fc42948b 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1633,12 +1633,6 @@ void RawRequestListInit(struct UsbDevice *deviceObj) HdfSListInit(&deviceObj->requestList); } -int32_t RawUsbMemTestTrigger(bool enable) -{ - g_usbRamTestFlag = enable; - return HDF_SUCCESS; -} - void *RawUsbMemAlloc(size_t size) { return RawUsbMemCalloc(size); -- Gitee From 7c22b5f4a6c27e277bd7bc1819abb67c0b64d1b5 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 02:37:39 +0000 Subject: [PATCH 0342/1485] =?UTF-8?q?=E3=80=90drivers=5Fperipheral?= =?UTF-8?q?=E3=80=91CI=E5=AE=89=E5=85=A8=E5=91=8A=E8=AD=A6--=E5=BC=82?= =?UTF-8?q?=E5=B8=B8=E5=88=86=E6=94=AF=E6=9C=AA=E5=85=B3=E9=97=AD=E8=B5=84?= =?UTF-8?q?=E6=BA=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 1 + 1 file changed, 1 insertion(+) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index c6a68d270c..1be355791a 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -352,6 +352,7 @@ static int32_t UsbFnAdapterCreatInterface(const char *interfaceName, int32_t nam ret = ioctl(fd, FUNCTIONFS_NEWFN, &fnnew); if (ret != 0) { HDF_LOGE("%{public}s: FUNCTIONFS_NEWFN failed", __func__); + UsbFnAdapterClosefn(fd); return HDF_ERR_IO; } ret = UsbFnAdapterClosefn(fd); -- Gitee From 9a37137975a61bbc52a5531b2ad0d37735494fd5 Mon Sep 17 00:00:00 2001 From: l60050612 Date: Sat, 24 Aug 2024 10:46:07 +0800 Subject: [PATCH 0343/1485] =?UTF-8?q?drivers=5Fperipheral=20display?= =?UTF-8?q?=E6=A8=A1=E5=9D=97=E7=8B=AC=E7=AB=8B=E7=BC=96=E8=AF=91=E4=B8=8D?= =?UTF-8?q?=E8=A7=84=E8=8C=83=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: l60050612 --- display/composer/test/unittest/BUILD.gn | 1 - 1 file changed, 1 deletion(-) diff --git a/display/composer/test/unittest/BUILD.gn b/display/composer/test/unittest/BUILD.gn index d24805bb7e..269e905829 100644 --- a/display/composer/test/unittest/BUILD.gn +++ b/display/composer/test/unittest/BUILD.gn @@ -32,7 +32,6 @@ ohos_unittest("composer_ut") { sources = [ "hdi_composer_ut.cpp" ] include_dirs = [ "../common", - "//commonlibrary/c_utils/base/include", ] deps = [ "../common:disp_dev_hdi_test_common" ] external_deps = [ -- Gitee From 8586b95fda23c7a2b36ea6053209ec1703d30654 Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 11:14:59 +0800 Subject: [PATCH 0344/1485] =?UTF-8?q?=E6=95=8F=E6=84=9F=E5=AD=97=E6=B8=85?= =?UTF-8?q?=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip.cpp | 2 +- wlan/chip/hdi_service/wifi_chip.h | 1 + wlan/chip/hdi_service/wifi_chip_modes.cpp | 2 -- wlan/chip/hdi_service/wifi_chip_modes.h | 1 + 4 files changed, 3 insertions(+), 3 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_chip.cpp b/wlan/chip/hdi_service/wifi_chip.cpp index 3a18c8eb02..7e8ce1a999 100644 --- a/wlan/chip/hdi_service/wifi_chip.cpp +++ b/wlan/chip/hdi_service/wifi_chip.cpp @@ -29,7 +29,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { constexpr int IFACE_TYPE_STA = 2; -constexpr int PROP_BOOL_VALUE_LEN = 6; + constexpr char K_ACTIVE_WLAN_IFACE_NAME_PROPERTY[] = "wifi.active.interface"; constexpr char K_NO_ACTIVE_WLAN_IFACE_NAME_PROPERTY_VALUE[] = ""; constexpr unsigned K_MAX_WLAN_IFACES = 5; diff --git a/wlan/chip/hdi_service/wifi_chip.h b/wlan/chip/hdi_service/wifi_chip.h index 1c661888ff..bdd66e98c8 100644 --- a/wlan/chip/hdi_service/wifi_chip.h +++ b/wlan/chip/hdi_service/wifi_chip.h @@ -36,6 +36,7 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { + class WifiChip : public IConcreteChip { public: WifiChip(int32_t chipId, bool isPrimary, diff --git a/wlan/chip/hdi_service/wifi_chip_modes.cpp b/wlan/chip/hdi_service/wifi_chip_modes.cpp index 166273d59f..e4ff9774f9 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.cpp +++ b/wlan/chip/hdi_service/wifi_chip_modes.cpp @@ -26,8 +26,6 @@ namespace V1_0 { #define AP IfaceType::AP #define P2P IfaceType::P2P -constexpr int PROP_BOOL_VALUE_LEN = 6; - WifiChipModes::WifiChipModes() {} UsableMode WifiChipModes::MakeComModes(int staNum, int apNum, int p2pNum, int modeId) diff --git a/wlan/chip/hdi_service/wifi_chip_modes.h b/wlan/chip/hdi_service/wifi_chip_modes.h index 0927006cee..50496bfd05 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.h +++ b/wlan/chip/hdi_service/wifi_chip_modes.h @@ -34,6 +34,7 @@ namespace Chip { namespace V1_0 { namespace chip_mode_ids { + constexpr int32_t K_INVALID = UINT32_MAX; constexpr int32_t K_V1_STA = 0; constexpr int32_t K_V1_AP = 1; -- Gitee From 2e1792a5133a6f7962d57b6993166cef72dc970f Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 03:22:38 +0000 Subject: [PATCH 0345/1485] update wlan/chip/hdi_service/wifi_chip.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip.cpp | 41 +---------------------------- 1 file changed, 1 insertion(+), 40 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_chip.cpp b/wlan/chip/hdi_service/wifi_chip.cpp index 7e8ce1a999..91e17c667c 100644 --- a/wlan/chip/hdi_service/wifi_chip.cpp +++ b/wlan/chip/hdi_service/wifi_chip.cpp @@ -29,7 +29,6 @@ namespace Wlan { namespace Chip { namespace V1_0 { constexpr int IFACE_TYPE_STA = 2; - constexpr char K_ACTIVE_WLAN_IFACE_NAME_PROPERTY[] = "wifi.active.interface"; constexpr char K_NO_ACTIVE_WLAN_IFACE_NAME_PROPERTY_VALUE[] = ""; constexpr unsigned K_MAX_WLAN_IFACES = 5; @@ -375,35 +374,6 @@ std::string WifiChip::AllocIfaceName(IfaceType type, uint32_t startIdx) return {}; } -std::vector GetPredefinedApIfaceNames(bool is_bridged) -{ - std::vector ifnames; - char propValue[PROP_MAX_LEN] = {0}; - int errCode = GetParameter(SAPCOEXIST_PROP, 0, propValue, PROP_BOOL_VALUE_LEN); - if (errCode > 0) { - if (strncmp(propValue, "true", strlen("true")) == 0) { - HDF_LOGI("support sapcoexist default interface wlan1"); - ifnames.push_back("wlan1"); - return ifnames; - } - } - std::array buffer; - buffer.fill(0); - errCode = GetParameter("ro.vendor.wifi.sap.interface", 0, buffer.data(), PROP_BOOL_VALUE_LEN); - if (errCode < 0) { - return ifnames; - } - ifnames.push_back(buffer.data()); - if (is_bridged) { - buffer.fill(0); - if (GetParameter("ro.vendor.wifi.sap.interface", 0, buffer.data(), PROP_BOOL_VALUE_LEN) < 0) { - return ifnames; - } - ifnames.push_back(buffer.data()); - } - return ifnames; -} - bool WifiChip::CanExpandedIfaceComboSupportIfaceCombo( const std::map& expandedCombo, const std::map& reqCombo) @@ -469,10 +439,6 @@ uint32_t WifiChip::IdxOfApIface() std::string WifiChip::AllocateApIfaceName() { - std::vector ifnames = GetPredefinedApIfaceNames(false); - if (!ifnames.empty()) { - return ifnames[0]; - } return AllocIfaceName(IfaceType::AP, IdxOfApIface()); } @@ -562,12 +528,7 @@ int32_t WifiChip::CreateP2pService(sptr& iface) std::string WifiChip::GetDefaultP2pIfaceName() { - std::array buffer; - int errCode = GetParameter("wifi.direct.interface", 0, buffer.data(), PROP_BOOL_VALUE_LEN); - if (errCode < 0) { - return "p2p0"; - } - return buffer.data(); + return "p2p0"; } int32_t WifiChip::GetP2pServiceIfNames(std::vector& ifnames) -- Gitee From a1e91c4e747ff157f23015fae236c0a38d0dc3d9 Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 03:23:41 +0000 Subject: [PATCH 0346/1485] update wlan/chip/hdi_service/wifi_chip.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip.h | 1 - 1 file changed, 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_chip.h b/wlan/chip/hdi_service/wifi_chip.h index bdd66e98c8..1c661888ff 100644 --- a/wlan/chip/hdi_service/wifi_chip.h +++ b/wlan/chip/hdi_service/wifi_chip.h @@ -36,7 +36,6 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { - class WifiChip : public IConcreteChip { public: WifiChip(int32_t chipId, bool isPrimary, -- Gitee From ebfc364dff470420289f342188757b598c1b9f47 Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 03:24:43 +0000 Subject: [PATCH 0347/1485] update wlan/chip/hdi_service/wifi_chip_modes.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip_modes.cpp | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_chip_modes.cpp b/wlan/chip/hdi_service/wifi_chip_modes.cpp index e4ff9774f9..985620722d 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.cpp +++ b/wlan/chip/hdi_service/wifi_chip_modes.cpp @@ -64,16 +64,6 @@ UsableMode WifiChipModes::MakeComModes(int staNum, int apNum, int p2pNum, int mo std::vector WifiChipModes::GetChipModesForPrimary() { std::vector modes = {}; - char propValue[PROP_MAX_LEN] = {0}; - int errCode = GetParameter(SAPCOEXIST_PROP, 0, propValue, PROP_BOOL_VALUE_LEN); - if (errCode > 0) { - if (strncmp(propValue, "true", strlen("true")) == 0) { - HDF_LOGI("select sap and sta coexist"); - UsableMode mode = MakeComModes(3, 1, 1, 0); - modes.push_back(mode); - return modes; - } - } UsableMode mode = MakeComModes(3, 0, 1, 0); modes.push_back(mode); UsableMode modeAp = MakeComModes(0, 1, 0, 1); -- Gitee From 89c11be23d8fee86ce4ab21cc84fe0d5e17508bd Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 03:25:27 +0000 Subject: [PATCH 0348/1485] update wlan/chip/hdi_service/wifi_chip_modes.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip_modes.h | 3 --- 1 file changed, 3 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_chip_modes.h b/wlan/chip/hdi_service/wifi_chip_modes.h index 50496bfd05..3b206d778b 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.h +++ b/wlan/chip/hdi_service/wifi_chip_modes.h @@ -23,8 +23,6 @@ #define SUBCHIP_PROP "ohos.boot.odm.conn.schiptype" #define PROP_SUBCHIPTYPE_LEN 10 #define SUPPORT_COEXCHIP "bisheng" -#define TRIPLE_MODE_PROP "vendor.hw_mc.wifi.triplemodes" -#define SAPCOEXIST_PROP "hw_mc.wifi.support_sapcoexist" #define PROP_MAX_LEN 128 namespace OHOS { @@ -34,7 +32,6 @@ namespace Chip { namespace V1_0 { namespace chip_mode_ids { - constexpr int32_t K_INVALID = UINT32_MAX; constexpr int32_t K_V1_STA = 0; constexpr int32_t K_V1_AP = 1; -- Gitee From 34cb35e0d71d93e35d6812507ffc01d1e6a51e6a Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 04:34:37 +0000 Subject: [PATCH 0349/1485] =?UTF-8?q?=E5=88=A0=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/host/src/usb_interface_pool.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index 0af31ec310..1b1d16d706 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1956,11 +1956,6 @@ OUT: return ret; } -int32_t UsbMemTestTrigger(bool enable) -{ - return RawUsbMemTestTrigger(enable); -} - bool UsbGetInterfaceActiveStatus( const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr, uint8_t interfaceIndex) { -- Gitee From 227914aaf1735d0c55ad88bf85c061c553164537 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 04:36:32 +0000 Subject: [PATCH 0350/1485] =?UTF-8?q?ACM=E5=86=85=E5=AD=98=E6=9C=AA?= =?UTF-8?q?=E9=87=8A=E6=94=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/serial/src/usb_serial_rawapi.c | 1 + 1 file changed, 1 insertion(+) diff --git a/usb/serial/src/usb_serial_rawapi.c b/usb/serial/src/usb_serial_rawapi.c index fdeaf7a6e9..a08858bb7c 100644 --- a/usb/serial/src/usb_serial_rawapi.c +++ b/usb/serial/src/usb_serial_rawapi.c @@ -1428,6 +1428,7 @@ static void UsbSerialDriverRelease(struct HdfDeviceObject *device) OsalMutexDestroy(&acm->lock); OsalMemFree(acm); acm = NULL; + device->service = NULL; HDF_LOGD("%{public}s:%{public}d exit", __func__, __LINE__); } -- Gitee From 8ffbc028f76aa3c7d45d20e3ad88c8e32e847265 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:26:08 +0000 Subject: [PATCH 0351/1485] update usb/ddk/device/src/adapter_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 31 ------------------------------- 1 file changed, 31 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 4701dee5e9..842593927d 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -1223,37 +1223,6 @@ void *UsbFnMemCalloc(size_t size) HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); return NULL; } - - if (g_usbRamTestFlag) { - if (g_usbRamTestHead == NULL) { - g_usbRamTestHead = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (g_usbRamTestHead == NULL) { - HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); - OsalMemFree(buf); - return NULL; - } - OsalMutexInit(&g_usbRamTestHead->lock); - DListHeadInit(&g_usbRamTestHead->list); - } - struct RawUsbRamTestList *testEntry = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (testEntry == NULL) { - HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); - OsalMemFree(buf); - return NULL; - } - testEntry->address = (uintptr_t)buf; - testEntry->size = size; - - struct RawUsbRamTestList *pos = NULL; - uint32_t totalSize = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DListInsertTail(&testEntry->list, &g_usbRamTestHead->list); - DLIST_FOR_EACH_ENTRY(pos, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - HDF_LOGI("%{public}s:add size = %{public}zu, totalSize = %{public}u", __func__, size, totalSize); - } return buf; } -- Gitee From 65333d748d440603320cfd54f6be8d73d6a3d32e Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:29:05 +0000 Subject: [PATCH 0352/1485] update usb/ddk/host/src/usb_raw_api_library.c. Signed-off-by: luzhiye --- usb/ddk/host/src/usb_raw_api_library.c | 34 -------------------------- 1 file changed, 34 deletions(-) diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 92fc42948b..a308e2d3be 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -1650,40 +1650,6 @@ void *RawUsbMemCalloc(size_t size) HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); return NULL; } - - if (g_usbRamTestFlag) { - if (g_usbRamTestHead == NULL) { - g_usbRamTestHead = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (g_usbRamTestHead == NULL) { - HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); - OsalMemFree(buf); - buf = NULL; - return NULL; - } - OsalMutexInit(&g_usbRamTestHead->lock); - DListHeadInit(&g_usbRamTestHead->list); - } - struct RawUsbRamTestList *testEntry = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (testEntry == NULL) { - HDF_LOGE("%{public}s:%{public}d testEntry is NULL", __func__, __LINE__); - OsalMemFree(buf); - buf = NULL; - return buf; - } - testEntry->address = (uintptr_t)buf; - testEntry->size = size; - - struct RawUsbRamTestList *pos = NULL; - uint32_t totalSize = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DListInsertTail(&testEntry->list, &g_usbRamTestHead->list); - DLIST_FOR_EACH_ENTRY(pos, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - - HDF_LOGI("%{public}s add size=%{public}d totalSize=%{public}d", __func__, (uint32_t)size, totalSize); - } return buf; } -- Gitee From ccf1256ce327fcff2700365d3b44221245d187ab Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:32:05 +0000 Subject: [PATCH 0353/1485] update usb/ddk/device/src/adapter_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 842593927d..70a5dfdde1 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -37,7 +37,6 @@ #define OPEN_CNT 30 static struct RawUsbRamTestList *g_usbRamTestHead = NULL; -static bool g_usbRamTestFlag = false; static bool IsDirExist(const char *path) { @@ -1233,25 +1232,6 @@ void UsbFnMemFree(const void *mem) return; } - if (g_usbRamTestFlag && g_usbRamTestHead != NULL) { - struct RawUsbRamTestList *pos = NULL; - struct RawUsbRamTestList *tmp = NULL; - uint32_t totalSize = 0; - uint32_t size = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - if (pos->address == (uintptr_t)mem) { - size = pos->size; - DListRemove(&pos->list); - OsalMemFree(pos); - continue; - } - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - HDF_LOGI("%{public}s:rm size = %{public}u, totalSize = %{public}u", __func__, size, totalSize); - } - if (mem != NULL) { OsalMemFree((void *)mem); mem = NULL; -- Gitee From 3bcf4e8dc9d173705d4b37d85b4e7b0ebe01c0f7 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:33:08 +0000 Subject: [PATCH 0354/1485] update usb/ddk/host/src/usb_raw_api_library.c. Signed-off-by: luzhiye --- usb/ddk/host/src/usb_raw_api_library.c | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index a308e2d3be..8e93dfbafc 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -22,7 +22,6 @@ struct UsbSession *g_usbRawDefaultSession = NULL; static struct RawUsbRamTestList *g_usbRamTestHead = NULL; -static bool g_usbRamTestFlag = false; static void SyncRequestCallback(const void *requestArg) { @@ -1660,25 +1659,6 @@ void RawUsbMemFree(void *mem) return; } - if (g_usbRamTestFlag && g_usbRamTestHead != NULL) { - struct RawUsbRamTestList *pos = NULL; - struct RawUsbRamTestList *tmp = NULL; - uint32_t totalSize = 0; - uint32_t size = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - if (pos->address == (uintptr_t)mem) { - size = pos->size; - DListRemove(&pos->list); - OsalMemFree(pos); - continue; - } - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - HDF_LOGI("%{public}s rm size=%{public}d totalSize=%{public}d", __func__, size, totalSize); - } - if (mem != NULL) { OsalMemFree(mem); mem = NULL; -- Gitee From b7c5fe8b9e4d84bf3675076f778d3a8700ccb7d6 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:41:18 +0000 Subject: [PATCH 0355/1485] =?UTF-8?q?=E5=BA=9F=E5=BC=83=E5=87=BD=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/device/include/adapter_if.h | 1 - usb/ddk/device/src/adapter_if_liteos.c | 57 -------------------------- 2 files changed, 58 deletions(-) diff --git a/usb/ddk/device/include/adapter_if.h b/usb/ddk/device/include/adapter_if.h index 3e20486bc6..c9c821bcfa 100644 --- a/usb/ddk/device/include/adapter_if.h +++ b/usb/ddk/device/include/adapter_if.h @@ -238,6 +238,5 @@ struct UsbFnAdapterOps *UsbFnAdapterGetOps(void); void *UsbFnMemAlloc(size_t size); void *UsbFnMemCalloc(size_t size); void UsbFnMemFree(const void *mem); -int32_t UsbFnAdpMemTestTrigger(bool enable); #endif /* USBFN_ADAPTER_H */ diff --git a/usb/ddk/device/src/adapter_if_liteos.c b/usb/ddk/device/src/adapter_if_liteos.c index 007ded01da..7673826efa 100644 --- a/usb/ddk/device/src/adapter_if_liteos.c +++ b/usb/ddk/device/src/adapter_if_liteos.c @@ -35,7 +35,6 @@ #define OPEN_CNT 30 static struct RawUsbRamTestList *g_usbRamTestHead = NULL; -static bool g_usbRamTestFlag = false; static int32_t UsbFnAdapterOpenFn(void) { @@ -1039,37 +1038,6 @@ static void *UsbFnMemCalloc(size_t size) return NULL; } - if (g_usbRamTestFlag) { - if (g_usbRamTestHead == NULL) { - g_usbRamTestHead = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (g_usbRamTestHead == NULL) { - HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); - OsalMemFree(buf); - return NULL; - } - OsalMutexInit(&g_usbRamTestHead->lock); - DListHeadInit(&g_usbRamTestHead->list); - } - struct RawUsbRamTestList *testEntry = OsalMemCalloc(sizeof(struct RawUsbRamTestList)); - if (testEntry == NULL) { - HDF_LOGE("%{public}s: %{public}d, OsalMemCalloc failed", __func__, __LINE__); - OsalMemFree(buf); - return NULL; - } - testEntry->address = (uintptr_t)buf; - testEntry->size = size; - - struct RawUsbRamTestList *pos = NULL; - uint32_t totalSize = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DListInsertTail(&testEntry->list, &g_usbRamTestHead->list); - DLIST_FOR_EACH_ENTRY(pos, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - - HDF_LOGI("%{public}s add size=%{public}d totalSize=%{public}d", __func__, (uint32_t)size, totalSize); - } return buf; } @@ -1080,37 +1048,12 @@ void UsbFnMemFree(const void *mem) return; } - if (g_usbRamTestFlag && (g_usbRamTestHead != NULL)) { - struct RawUsbRamTestList *pos = NULL; - struct RawUsbRamTestList *tmp = NULL; - uint32_t totalSize = 0; - uint32_t size = 0; - OsalMutexLock(&g_usbRamTestHead->lock); - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &g_usbRamTestHead->list, struct RawUsbRamTestList, list) { - if (pos->address == (uintptr_t)mem) { - size = pos->size; - DListRemove(&pos->list); - OsalMemFree(pos); - continue; - } - totalSize += pos->size; - } - OsalMutexUnlock(&g_usbRamTestHead->lock); - HDF_LOGE("%{public}s:rm size = %{public}u, totalSize = %{public}u", __func__, size, totalSize); - } - if (mem != NULL) { OsalMemFree((void *)mem); mem = NULL; } } -int32_t UsbFnAdpMemTestTrigger(bool enable) -{ - g_usbRamTestFlag = enable; - return HDF_SUCCESS; -} - static struct UsbFnAdapterOps g_usbFnAdapter = { .createDevice = UsbFnAdapterCreateDevice, .delDevice = UsbFnAdapterDelDevice, -- Gitee From 292a408860d0086a81513b3c26cce1a1be070e64 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:44:28 +0000 Subject: [PATCH 0356/1485] =?UTF-8?q?=E8=A1=A5=E5=85=85=E5=88=A0=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/ddk/host/include/usb_raw_api_library.h | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/ddk/host/include/usb_raw_api_library.h b/usb/ddk/host/include/usb_raw_api_library.h index aeca8d6237..ba80748684 100644 --- a/usb/ddk/host/include/usb_raw_api_library.h +++ b/usb/ddk/host/include/usb_raw_api_library.h @@ -136,7 +136,6 @@ void RawRequestListInit(struct UsbDevice *deviceObj); void *RawUsbMemAlloc(size_t size); void *RawUsbMemCalloc(size_t size); void RawUsbMemFree(void *mem); -int32_t RawUsbMemTestTrigger(bool enable); int32_t RawClaimInterfaceForce(struct UsbDeviceHandle *devHandle, uint32_t interfaceNumber); void RawAttachKernelDriver(struct UsbDeviceHandle *devHandle, uint8_t interfaceNumber); int32_t RawAttachInterface(struct UsbDeviceHandle *devHandle, uint32_t interfaceNumber); -- Gitee From 981a7041f2078e7d191e2eed6d12093591bcfd3a Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 06:48:27 +0000 Subject: [PATCH 0357/1485] =?UTF-8?q?=E5=BA=9F=E5=BC=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: luzhiye --- usb/interfaces/ddk/device/usbfn_device.h | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/interfaces/ddk/device/usbfn_device.h b/usb/interfaces/ddk/device/usbfn_device.h index 94bbaabd1b..31117b9d8e 100644 --- a/usb/interfaces/ddk/device/usbfn_device.h +++ b/usb/interfaces/ddk/device/usbfn_device.h @@ -194,7 +194,6 @@ int32_t UsbFnGetDeviceState(struct UsbFnDevice *fnDevice, UsbFnDeviceState *devS * returns NULL otherwise. */ const struct UsbFnInterface *UsbFnGetInterface(struct UsbFnDevice *fnDevice, uint8_t interfaceIndex); -int32_t UsbFnMemTestTrigger(bool enable); #ifdef __cplusplus } -- Gitee From 5cb98d3e95aa878fe8a1245c69f4e084ff4bf359 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Sat, 24 Aug 2024 06:54:37 +0000 Subject: [PATCH 0358/1485] update audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c index 6c8544be7d..9d7ea7e593 100644 --- a/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c +++ b/audio/hdi_service/primary_impl/vdi_src/audio_manager_vdi.c @@ -224,7 +224,7 @@ static int32_t AudioManagerVdiDescsToDescs(struct AudioAdapterDescriptorVdi *vdi return HDF_SUCCESS; } -int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, +static int32_t AudioManagerPrivVdiGetAllAdapters(struct AudioManagerPrivVdi *priv, struct AudioAdapterDescriptor *descs, uint32_t *descsLen) { int32_t ret; -- Gitee From e1109660078cf7b74a32457655f6d73fafb88df1 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Sat, 24 Aug 2024 15:50:56 +0800 Subject: [PATCH 0359/1485] HDI cleancode Signed-off-by: suxiaosu007 --- .../hal/idl_service/include/codec_dfx_service.h | 2 -- codec/hal/idl_service/include/component_node.h | 2 +- codec/hal/idl_service/src/codec_dfx_service.cpp | 15 +-------------- codec/hal/idl_service/src/component_node.cpp | 16 ++++++++++++---- codec/hal/src/codec_component_type_stub.c | 3 +++ codec/hal/src/codec_dfx_service.c | 4 ++++ 6 files changed, 21 insertions(+), 21 deletions(-) diff --git a/codec/hal/idl_service/include/codec_dfx_service.h b/codec/hal/idl_service/include/codec_dfx_service.h index 1b44770b78..db4d600385 100644 --- a/codec/hal/idl_service/include/codec_dfx_service.h +++ b/codec/hal/idl_service/include/codec_dfx_service.h @@ -41,8 +41,6 @@ protected: CodecDfxService() = default; private: - void GetBuffCount(const std::shared_ptr &dumpNode, - uint32_t &inputBuffCount, uint32_t &outputBuffCount); sptr managerService_; static CodecDfxService dfxInstance_; static HdfSBuf *reply_; diff --git a/codec/hal/idl_service/include/component_node.h b/codec/hal/idl_service/include/component_node.h index c325bb6f18..02477707d0 100644 --- a/codec/hal/idl_service/include/component_node.h +++ b/codec/hal/idl_service/include/component_node.h @@ -65,8 +65,8 @@ public: uint32_t data2, void *eventData); OMX_ERRORTYPE static OnEmptyBufferDone(OMX_HANDLETYPE component, void *appData, OMX_BUFFERHEADERTYPE *buffer); OMX_ERRORTYPE static OnFillBufferDone(OMX_HANDLETYPE component, void *appData, OMX_BUFFERHEADERTYPE *buffer); - const std::map &GetBufferMapCount(); void ReleaseOMXResource(); + void GetBuffCount(uint32_t &inputBuffCount, uint32_t &outputBuffCount); public: static OMX_CALLBACKTYPE callbacks_; // callbacks diff --git a/codec/hal/idl_service/src/codec_dfx_service.cpp b/codec/hal/idl_service/src/codec_dfx_service.cpp index f20ced1858..911ef706cb 100644 --- a/codec/hal/idl_service/src/codec_dfx_service.cpp +++ b/codec/hal/idl_service/src/codec_dfx_service.cpp @@ -25,19 +25,6 @@ namespace V3_0 { #define OUTPUT_PORT_INDEX 1 CodecDfxService CodecDfxService::dfxInstance_; HdfSBuf *CodecDfxService::reply_; -void CodecDfxService::GetBuffCount(const std::shared_ptr &dumpNode, - uint32_t &inputBuffCount, uint32_t &outputBuffCount) -{ - auto iter = dumpNode->GetBufferMapCount().begin(); - while (iter != dumpNode->GetBufferMapCount().end()) { - if (iter->second == INPUT_PORT_INDEX) { - inputBuffCount++; - } else { - outputBuffCount++; - } - iter++; - } -} int32_t CodecDfxService::GetCodecComponentListInfo(struct HdfSBuf *reply) { @@ -66,7 +53,7 @@ int32_t CodecDfxService::GetCodecComponentListInfo(struct HdfSBuf *reply) } dumpNode->GetState(state); dump.append(std::to_string(state)); - GetInstance().GetBuffCount(dumpNode, inputBuffCount, outputBuffCount); + dumpNode->GetBuffCount(inputBuffCount, outputBuffCount); dump.append(", inputPortIndex = ") .append(std::to_string(INPUT_PORT_INDEX)) .append(", inputBuffCount = ") diff --git a/codec/hal/idl_service/src/component_node.cpp b/codec/hal/idl_service/src/component_node.cpp index ac713ede9a..3d44f36b9f 100644 --- a/codec/hal/idl_service/src/component_node.cpp +++ b/codec/hal/idl_service/src/component_node.cpp @@ -612,7 +612,7 @@ int32_t ComponentNode::UseBufferByType(uint32_t portIndex, OmxCodecBuffer &buffe uint32_t ComponentNode::GenerateBufferId() { - std::shared_lock lk(mapMutex_); + std::unique_lock lk(mapMutex_); uint32_t bufferId = 0; do { if (++bufferIdCount_ == 0) { @@ -685,9 +685,17 @@ void ComponentNode::WaitStateChange(CodecStateType objState, CodecStateType &sta } } -const std::map &ComponentNode::GetBufferMapCount() -{ - return portIndexMap_; +void ComponentNode::GetBuffCount(uint32_t &inputBuffCount, uint32_t &outputBuffCount) { + std::unique_lock lk(mapMutex_); + auto iter = portIndexMap_.begin(); + while (iter != portIndexMap_.end()) { + if (iter->second == 0) { + inputBuffCount++; + } else { + outputBuffCount++; + } + iter++; + } } void ComponentNode::ReleaseOMXResource() diff --git a/codec/hal/src/codec_component_type_stub.c b/codec/hal/src/codec_component_type_stub.c index 8e83d4a08c..556a7a225d 100644 --- a/codec/hal/src/codec_component_type_stub.c +++ b/codec/hal/src/codec_component_type_stub.c @@ -626,14 +626,17 @@ static int32_t SerStubSetCallbacks(struct CodecComponentType *serviceImpl, struc if (!HdfSbufReadInt64(data, &appData)) { CODEC_LOGE("read appData size failed!"); + CodecCallbackTypeRelease(callback); return HDF_ERR_INVALID_PARAM; } ret = serviceImpl->SetCallbacks(serviceImpl, callback, appData); if (ret != HDF_SUCCESS) { CODEC_LOGE("call SetCallbacks function failed!"); + CodecCallbackTypeRelease(callback); return ret; } + CodecCallbackTypeRelease(callback); return ret; } diff --git a/codec/hal/src/codec_dfx_service.c b/codec/hal/src/codec_dfx_service.c index ee1a4597a4..9b5fe0f7af 100644 --- a/codec/hal/src/codec_dfx_service.c +++ b/codec/hal/src/codec_dfx_service.c @@ -29,6 +29,10 @@ int32_t DevCodecHostDump(struct HdfSBuf *data, struct HdfSBuf *reply) return HDF_SUCCESS; } const char *para = HdfSbufReadString(data); + if (para == NULL) { + CODEC_LOGE("para is NULL"); + return HDF_FAILURE; + } if (strcmp(para, "-h") == 0) { HdfSbufWriteString(reply, "-h: codec dump help ! \n"); HdfSbufWriteString(reply, "-l: dump codec components info list ! \n"); -- Gitee From 9a181befbacf3733c575b918d4b246a2fab5869f Mon Sep 17 00:00:00 2001 From: Sxs Date: Sat, 24 Aug 2024 08:05:41 +0000 Subject: [PATCH 0360/1485] update codec/hal/idl_service/src/component_node.cpp. Signed-off-by: Sxs --- codec/hal/idl_service/src/component_node.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/codec/hal/idl_service/src/component_node.cpp b/codec/hal/idl_service/src/component_node.cpp index 3d44f36b9f..64a74f9462 100644 --- a/codec/hal/idl_service/src/component_node.cpp +++ b/codec/hal/idl_service/src/component_node.cpp @@ -685,7 +685,8 @@ void ComponentNode::WaitStateChange(CodecStateType objState, CodecStateType &sta } } -void ComponentNode::GetBuffCount(uint32_t &inputBuffCount, uint32_t &outputBuffCount) { +void ComponentNode::GetBuffCount(uint32_t &inputBuffCount, uint32_t &outputBuffCount) +{ std::unique_lock lk(mapMutex_); auto iter = portIndexMap_.begin(); while (iter != portIndexMap_.end()) { -- Gitee From d59ace1a2493c738df1c3827b7cdd94f2de1e06d Mon Sep 17 00:00:00 2001 From: l60050612 Date: Sat, 24 Aug 2024 08:08:56 +0000 Subject: [PATCH 0361/1485] update display/composer/test/unittest/BUILD.gn. Signed-off-by: l60050612 --- display/composer/test/unittest/BUILD.gn | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/display/composer/test/unittest/BUILD.gn b/display/composer/test/unittest/BUILD.gn index 269e905829..2eebb9964b 100644 --- a/display/composer/test/unittest/BUILD.gn +++ b/display/composer/test/unittest/BUILD.gn @@ -30,9 +30,7 @@ config("module_private_config") { ohos_unittest("composer_ut") { module_out_path = module_output_path sources = [ "hdi_composer_ut.cpp" ] - include_dirs = [ - "../common", - ] + include_dirs = [ "../common" ] deps = [ "../common:disp_dev_hdi_test_common" ] external_deps = [ "c_utils:utils", -- Gitee From 97f334ad6cb36944ff49b679e079e4f1ec93983e Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 08:25:18 +0000 Subject: [PATCH 0362/1485] update usb/ddk/device/src/adapter_if.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/usb/ddk/device/src/adapter_if.c b/usb/ddk/device/src/adapter_if.c index 70a5dfdde1..0384719b0d 100644 --- a/usb/ddk/device/src/adapter_if.c +++ b/usb/ddk/device/src/adapter_if.c @@ -36,8 +36,6 @@ #define SLEEP_DELAY 100000 #define OPEN_CNT 30 -static struct RawUsbRamTestList *g_usbRamTestHead = NULL; - static bool IsDirExist(const char *path) { DIR *dir = NULL; -- Gitee From a743de3d266d8858a29af277443a95f8ac016b67 Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 08:25:51 +0000 Subject: [PATCH 0363/1485] update usb/ddk/device/src/adapter_if_liteos.c. Signed-off-by: luzhiye --- usb/ddk/device/src/adapter_if_liteos.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/usb/ddk/device/src/adapter_if_liteos.c b/usb/ddk/device/src/adapter_if_liteos.c index 7673826efa..80aa01e9dc 100644 --- a/usb/ddk/device/src/adapter_if_liteos.c +++ b/usb/ddk/device/src/adapter_if_liteos.c @@ -34,8 +34,6 @@ #define SLEEP_TIME 100000 #define OPEN_CNT 30 -static struct RawUsbRamTestList *g_usbRamTestHead = NULL; - static int32_t UsbFnAdapterOpenFn(void) { int32_t i; -- Gitee From 5e2c5517e54e035ab31c72c045889cc306b4081d Mon Sep 17 00:00:00 2001 From: luzhiye Date: Sat, 24 Aug 2024 08:27:36 +0000 Subject: [PATCH 0364/1485] update usb/ddk/host/src/usb_raw_api_library.c. Signed-off-by: luzhiye --- usb/ddk/host/src/usb_raw_api_library.c | 1 - 1 file changed, 1 deletion(-) diff --git a/usb/ddk/host/src/usb_raw_api_library.c b/usb/ddk/host/src/usb_raw_api_library.c index 8e93dfbafc..70ecafc136 100644 --- a/usb/ddk/host/src/usb_raw_api_library.c +++ b/usb/ddk/host/src/usb_raw_api_library.c @@ -21,7 +21,6 @@ #define HDF_LOG_TAG USB_RAW_API_LIBRARY struct UsbSession *g_usbRawDefaultSession = NULL; -static struct RawUsbRamTestList *g_usbRamTestHead = NULL; static void SyncRequestCallback(const void *requestArg) { -- Gitee From d081322a4c65c36191ff279f90650734d254f3a0 Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 08:31:41 +0000 Subject: [PATCH 0365/1485] update wlan/chip/hdi_service/wifi_chip.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/wlan/chip/hdi_service/wifi_chip.cpp b/wlan/chip/hdi_service/wifi_chip.cpp index c7e4974cb5..365cf6ecdf 100644 --- a/wlan/chip/hdi_service/wifi_chip.cpp +++ b/wlan/chip/hdi_service/wifi_chip.cpp @@ -68,10 +68,11 @@ WifiChip::WifiChip( vendorHal_(vendorHal), isValid_(true), currentModeId_(chip_mode_ids::K_INVALID), - ifaceUtil_(ifaceUtil), - vendorHal_.lock()->GetChipModes(isPrimary, modes_), + ifaceUtil_(ifaceUtil), subsystemCallbackHandler_(handler) -{} +{ + vendorHal_.lock()->GetChipModes(isPrimary, modes_); +} WifiChip::~WifiChip() {} -- Gitee From c5775f3e8b9ff92eac10e05a5389aa9b077bb756 Mon Sep 17 00:00:00 2001 From: xionglei Date: Sat, 24 Aug 2024 08:33:16 +0000 Subject: [PATCH 0366/1485] update wlan/chip/hdi_service/wifi_hal.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_hal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_hal.h b/wlan/chip/hdi_service/wifi_hal.h index 70611df304..0146b5b2ba 100644 --- a/wlan/chip/hdi_service/wifi_hal.h +++ b/wlan/chip/hdi_service/wifi_hal.h @@ -111,7 +111,7 @@ typedef struct { WifiError (*wifiSetCountryCode)(wifiInterfaceHandle handle, const char *); WifiError (*getPowerMode)(const char *, int *); WifiError (*setPowerMode)(const char *, int); - WifiError (*GetChipModes)(bool, std::vector& modes); + WifiError (*GetChipModes)(bool, std::vector& modes); WifiError (*wifiStartScan)(wifiInterfaceHandle handle, const OHOS::HDI::Wlan::Chip::V1_0::ScanParams& scanParam); WifiError (*wifiStartPnoScan)(wifiInterfaceHandle handle, -- Gitee From 4025f3f90085e0fe07cf42b2c0405ccc8c997b47 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Sat, 24 Aug 2024 17:06:44 +0800 Subject: [PATCH 0367/1485] codec HDI eos handle bugfix Signed-off-by: suxiaosu007 --- codec/hal/idl_service/src/codec_dyna_buffer.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/codec/hal/idl_service/src/codec_dyna_buffer.cpp b/codec/hal/idl_service/src/codec_dyna_buffer.cpp index c9439fc65c..e063b064db 100644 --- a/codec/hal/idl_service/src/codec_dyna_buffer.cpp +++ b/codec/hal/idl_service/src/codec_dyna_buffer.cpp @@ -73,9 +73,6 @@ int32_t CodecDynaBuffer::EmptyOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX_ CODEC_LOGE("CheckInvalid return false"); return HDF_ERR_INVALID_PARAM; } - buffer_ = nullptr; - dynaBuffer_.bufferHandle = nullptr; - codecBuffer.filledLen = 0; if (codecBuffer.bufferhandle != nullptr) { BufferHandle* handle = codecBuffer.bufferhandle->GetBufferHandle(); if (handle != nullptr) { -- Gitee From 0184b40a4473db565664bc3e2aa08ac4d605d37e Mon Sep 17 00:00:00 2001 From: w30042960 Date: Tue, 20 Aug 2024 19:59:51 +0800 Subject: [PATCH 0368/1485] add ext1 Signed-off-by: w30042960 --- .../v1_0/include/audio_render_ext_impl.h | 141 +++++ .../audio/v1_0/src/audio_render_ext_impl.cpp | 562 ++++++++++++++++++ 2 files changed, 703 insertions(+) create mode 100644 distributed_audio/hdi_service/audio/v1_0/include/audio_render_ext_impl.h create mode 100644 distributed_audio/hdi_service/audio/v1_0/src/audio_render_ext_impl.cpp diff --git a/distributed_audio/hdi_service/audio/v1_0/include/audio_render_ext_impl.h b/distributed_audio/hdi_service/audio/v1_0/include/audio_render_ext_impl.h new file mode 100644 index 0000000000..8b36f53f25 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/include/audio_render_ext_impl.h @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_AUDIO_RENDER_EXT_IMPL_H +#define OHOS_AUDIO_RENDER_EXT_IMPL_H + +#include +#include +#include + +#include "ashmem.h" +#include "audio_render_interface_impl_base.h" +#include "daudio_utils.h" + +#include +#include +#include + +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioData; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::AudioParameter; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::CurrentTime; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioCallback; +class AudioRenderExtImpl : public AudioRenderInterfaceImplBase { +public: + AudioRenderExtImpl(); + ~AudioRenderExtImpl() override; + + int32_t GetLatency(uint32_t &ms) override; + int32_t RenderFrame(const std::vector &frame, uint64_t &replyBytes) override; + int32_t GetRenderPosition(uint64_t &frames, AudioTimeStamp &time) override; + int32_t SetRenderSpeed(float speed) override; + int32_t GetRenderSpeed(float &speed) override; + int32_t SetChannelMode(AudioChannelMode mode) override; + int32_t GetChannelMode(AudioChannelMode &mode) override; + int32_t RegCallback(const sptr &audioCallback, int8_t cookie) override; + int32_t DrainBuffer(AudioDrainNotifyType &type) override; + int32_t IsSupportsDrain(bool &support) override; + int32_t CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported) override; + int32_t SelectScene(const AudioSceneDescriptor &scene) override; + int32_t SetMute(bool mute) override; + int32_t GetMute(bool &mute) override; + int32_t SetVolume(float volume) override; + int32_t GetVolume(float &volume) override; + int32_t GetGainThreshold(float &min, float &max) override; + int32_t SetGain(float gain) override; + int32_t GetGain(float &gain) override; + int32_t GetFrameSize(uint64_t &size) override; + int32_t GetFrameCount(uint64_t &count) override; + int32_t SetSampleAttributes(const AudioSampleAttributes &attrs) override; + int32_t GetSampleAttributes(AudioSampleAttributes &attrs) override; + int32_t GetCurrentChannelId(uint32_t &channelId) override; + int32_t SetExtraParams(const std::string &keyValueList) override; + int32_t GetExtraParams(std::string &keyValueList) override; + int32_t ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc) override; + int32_t GetMmapPosition(uint64_t &frames, AudioTimeStamp &time) override; + int32_t AddAudioEffect(uint64_t effectid) override; + int32_t RemoveAudioEffect(uint64_t effectid) override; + int32_t GetFrameBufferSize(uint64_t &bufferSize) override; + int32_t Start() override; + int32_t Stop() override; + int32_t Pause() override; + int32_t Resume() override; + int32_t Flush() override; + int32_t TurnStandbyMode() override; + int32_t AudioDevDump(int32_t range, int32_t fd) override; + int32_t IsSupportsPauseAndResume(bool &supportPause, bool &supportResume) override; + const AudioDeviceDescriptor &GetRenderDesc() override; + void SetVolumeInner(const uint32_t vol) override; + void SetVolumeRangeInner(const uint32_t volMax, const uint32_t volMin) override; + uint32_t GetVolumeInner() override; + uint32_t GetMaxVolumeInner() override; + uint32_t GetMinVolumeInner() override; + void SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, + const sptr &callback, const int32_t dhId) override; + void SetDumpFlagInner() override; + +private: + float GetFadeRate(uint32_t currentIndex, const uint32_t durationIndex); + int32_t FadeInProcess(const uint32_t durationFrame, int8_t* frameData, const size_t frameLength); + int32_t InitAshmem(int32_t ashmemLength); + void UnInitAshmem(); + +private: + std::string adapterName_; + int32_t dhId_ = 0; + uint32_t renderId_ = 0; + AudioDeviceDescriptor devDesc_ = {}; + AudioSampleAttributes devAttrs_ = {}; + + uint32_t timeInterval_ = AUDIO_MMAP_NOIRQ_INTERVAL; + uint32_t minTimeInterval_ = 30; + uint32_t maxTimeInterval_ = 80; + float renderSpeed_ = 0; + uint32_t currentFrame_ = 0; + std::mutex renderMtx_; + AudioChannelMode channelMode_ = AUDIO_CHANNEL_NORMAL; + AudioRenderStatus renderStatus_ = RENDER_STATUS_CLOSE; + sptr audioExtCallback_ = nullptr; + sptr renderCallback_ = nullptr; + bool firstOpenFlag_ = true; + OHOS::sptr ashmem_ = nullptr; + int32_t ashmemLength_ = 0; + int32_t lengthPerTrans_ = 0; + int32_t fd_ = 0; + + std::mutex volMtx_; + uint32_t vol_ = 0; + uint32_t volMax_ = 0; + uint32_t volMin_ = 0; +}; +#ifdef __cplusplus +extern "C" { +#endif +__attribute__((visibility("default"))) AudioRenderInterfaceImplBase *GetRenderImplExt(); +#ifdef __cplusplus +} +#endif +} // namespace V1_0 +} // namespace Audio +} // namespace DistributedAudio +} // namespace HDI +} // namespace OHOS +#endif // OHOS_AUDIO_RENDER_EXT_IMPL_H diff --git a/distributed_audio/hdi_service/audio/v1_0/src/audio_render_ext_impl.cpp b/distributed_audio/hdi_service/audio/v1_0/src/audio_render_ext_impl.cpp new file mode 100644 index 0000000000..5e4eed7d64 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/src/audio_render_ext_impl.cpp @@ -0,0 +1,562 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "audio_render_ext_impl.h" + +#include +#include +#include "sys/time.h" + +#include "cJSON.h" + +#include "daudio_constants.h" +#include "daudio_events.h" +#include "daudio_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AudioRenderExtImpl" + +using namespace OHOS::DistributedHardware; +namespace OHOS { +namespace HDI { +namespace DistributedAudio { +namespace Audio { +namespace V1_0 { +AudioRenderExtImpl::AudioRenderExtImpl() +{ + DHLOGI("Distributed lowlatency render constructed."); +} + +AudioRenderExtImpl::~AudioRenderExtImpl() +{ + UnInitAshmem(); + DHLOGI("Distributed lowlatency render destructed, id(%{public}d).", devDesc_.pins); +} + +int32_t AudioRenderExtImpl::InitAshmem(int32_t ashmemLength) +{ + std::string memory_name = "Render ShareMemory"; + if (ashmemLength < DAUDIO_MIN_ASHMEM_LEN || ashmemLength > DAUDIO_MAX_ASHMEM_LEN) { + DHLOGE("Init ashmem failed. length is illegal."); + return HDF_FAILURE; + } + ashmem_ = OHOS::Ashmem::CreateAshmem(memory_name.c_str(), ashmemLength); + if (ashmem_ == nullptr) { + DHLOGE("Create ashmem failed."); + return HDF_FAILURE; + } + bool ret = ashmem_->MapReadAndWriteAshmem(); + if (ret != true) { + DHLOGE("Mmap ashmem failed."); + return HDF_FAILURE; + } + fd_ = ashmem_->GetAshmemFd(); + DHLOGI("Init Ashmem success, fd: %{public}d, length: %{public}d", fd_, ashmemLength); + return HDF_SUCCESS; +} + +void AudioRenderExtImpl::UnInitAshmem() +{ + if (ashmem_ != nullptr) { + ashmem_->UnmapAshmem(); + ashmem_->CloseAshmem(); + ashmem_ = nullptr; + DHLOGI("UnInitAshmem success."); + } +} + +int32_t AudioRenderExtImpl::GetLatency(uint32_t &ms) +{ + DHLOGD("Get render device latency, not support yet."); + ms = 0; + return HDF_SUCCESS; +} + +float AudioRenderExtImpl::GetFadeRate(uint32_t currentIndex, const uint32_t durationIndex) +{ + if (currentIndex > durationIndex || durationIndex == 0) { + return 1.0f; + } + + float fadeRate = static_cast(currentIndex) / durationIndex * DAUDIO_FADE_NORMALIZATION_FACTOR; + if (fadeRate < 1) { + return pow(fadeRate, DAUDIO_FADE_POWER_NUM) / DAUDIO_FADE_NORMALIZATION_FACTOR; + } + return -pow(fadeRate - DAUDIO_FADE_MAXIMUM_VALUE, DAUDIO_FADE_POWER_NUM) / + DAUDIO_FADE_NORMALIZATION_FACTOR + 1; +} + +int32_t AudioRenderExtImpl::FadeInProcess(const uint32_t durationFrame, + int8_t* frameData, const size_t frameLength) +{ + int16_t* frame = reinterpret_cast(frameData); + const size_t newFrameLength = frameLength / 2; + if (durationFrame < 1) { + return HDF_FAILURE; + } + for (size_t k = 0; k < newFrameLength; ++k) { + float rate = GetFadeRate(currentFrame_ * newFrameLength + k, durationFrame * newFrameLength); + frame[k] = currentFrame_ == durationFrame - 1 ? frame[k] : static_cast(rate * frame[k]); + } + DHLOGI("Fade-in frame[currentFrame: %{public}d].", currentFrame_); + ++currentFrame_; + currentFrame_ = currentFrame_ >= durationFrame ? durationFrame - 1 : currentFrame_; + + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::RenderFrame(const std::vector &frame, uint64_t &replyBytes) +{ + DHLOGD("Render frame. not support in low-latency render"); + (void)devAttrs_.sampleRate; + (void)devAttrs_.channelCount; + (void)devAttrs_.format; + + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetRenderPosition(uint64_t &frames, AudioTimeStamp &time) +{ + DHLOGD("Get render position, not support yet."); + (void)frames; + (void)time; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetRenderSpeed(float speed) +{ + DHLOGD("Set render speed, control render speed is not support yet."); + renderSpeed_ = speed; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetRenderSpeed(float &speed) +{ + DHLOGD("Get render speed, control render speed is not support yet."); + speed = renderSpeed_; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetChannelMode(AudioChannelMode mode) +{ + DHLOGD("Set channel mode, control channel mode is not support yet."); + channelMode_ = mode; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetChannelMode(AudioChannelMode &mode) +{ + DHLOGD("Get channel mode, control channel mode is not support yet."); + mode = channelMode_; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::RegCallback(const sptr &audioCallback, int8_t cookie) +{ + DHLOGI("Register render callback."); + (void)cookie; + renderCallback_ = audioCallback; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::DrainBuffer(AudioDrainNotifyType &type) +{ + DHLOGD("Drain audio buffer, not support yet."); + (void)type; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::IsSupportsDrain(bool &support) +{ + DHLOGD("Check whether drain is supported, not support yet."); + (void)support; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::Start() +{ + DHLOGI("Start render mmap."); + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + if (firstOpenFlag_) { + firstOpenFlag_ = false; + } else { + std::string content; + std::initializer_list> items = { {"ChangeType", HDF_EVENT_RESTART}, + {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content }; + int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Restart failed."); + } + } + std::string content; + std::initializer_list> items = { {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + DAudioEvent event = { HDF_AUDIO_EVENT_MMAP_START, content }; + int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Start render mmap failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::Stop() +{ + DHLOGI("Stop render mmap."); + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + std::string content; + std::initializer_list> items = { {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + DAudioEvent event = { HDF_AUDIO_EVENT_MMAP_STOP, content }; + int32_t ret = audioExtCallback_->NotifyEvent(renderId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Stop render mmap failed."); + return HDF_FAILURE; + } + items = { {"ChangeType", HDF_EVENT_PAUSE}, + {KEY_DH_ID, std::to_string(dhId_)} }; + if (WrapCJsonItem(items, content) != HDF_SUCCESS) { + DHLOGE("Wrap the event failed."); + return HDF_FAILURE; + } + event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content }; + ret = audioExtCallback_->NotifyEvent(renderId_, event); + if (ret != HDF_SUCCESS) { + DHLOGE("Pause and clear cache streams failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::Pause() +{ + DHLOGI("Pause render."); + std::lock_guard renderLck(renderMtx_); + renderStatus_ = RENDER_STATUS_PAUSE; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::Resume() +{ + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::Flush() +{ + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::TurnStandbyMode() +{ + DHLOGD("Turn stand by mode, not support yet."); + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::AudioDevDump(int32_t range, int32_t fd) +{ + DHLOGD("Dump audio info, not support yet."); + (void)range; + (void)fd; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::IsSupportsPauseAndResume(bool &supportPause, bool &supportResume) +{ + DHLOGD("Check whether pause and resume is supported, not support yet."); + (void)supportPause; + (void)supportResume; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::CheckSceneCapability(const AudioSceneDescriptor &scene, bool &supported) +{ + DHLOGD("Check scene capability."); + (void)scene; + (void)supported; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SelectScene(const AudioSceneDescriptor &scene) +{ + DHLOGD("Select audio scene, not support yet."); + (void)scene; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetMute(bool mute) +{ + DHLOGD("Set mute, not support yet."); + (void)mute; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetMute(bool &mute) +{ + DHLOGD("Get mute, not support yet."); + (void)mute; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetVolume(float volume) +{ + DHLOGD("Can not set vol not by this interface."); + (void)volume; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetVolume(float &volume) +{ + DHLOGD("Can not get vol not by this interface."); + (void)volume; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetGainThreshold(float &min, float &max) +{ + DHLOGD("Get gain threshold, not support yet."); + min = 0; + max = 0; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetGain(float gain) +{ + DHLOGD("Set gain, not support yet."); + (void) gain; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetGain(float &gain) +{ + DHLOGD("Get gain, not support yet."); + gain = 1.0; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetFrameSize(uint64_t &size) +{ + (void)size; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetFrameCount(uint64_t &count) +{ + (void)count; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetSampleAttributes(const AudioSampleAttributes &attrs) +{ + DHLOGI("Set sample attributes."); + devAttrs_ = attrs; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetSampleAttributes(AudioSampleAttributes &attrs) +{ + DHLOGI("Get sample attributes."); + attrs = devAttrs_; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetCurrentChannelId(uint32_t &channelId) +{ + DHLOGD("Get current channel id, not support yet."); + (void)channelId; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::SetExtraParams(const std::string &keyValueList) +{ + DHLOGD("Set extra parameters, not support yet."); + (void)keyValueList; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetExtraParams(std::string &keyValueList) +{ + DHLOGD("Get extra parameters, not support yet."); + (void)keyValueList; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::ReqMmapBuffer(int32_t reqSize, AudioMmapBufferDescriptor &desc) +{ + DHLOGI("Request mmap buffer."); + int32_t minSize = CalculateSampleNum(devAttrs_.sampleRate, minTimeInterval_); + int32_t maxSize = CalculateSampleNum(devAttrs_.sampleRate, maxTimeInterval_); + int32_t realSize = reqSize; + if (reqSize < minSize) { + realSize = minSize; + } else if (reqSize > maxSize) { + realSize = maxSize; + } + DHLOGI("ReqMmap buffer realsize : %{public}d, minsize: %{public}d, maxsize:%{public}d.", + realSize, minSize, maxSize); + desc.totalBufferFrames = realSize; + ashmemLength_ = realSize * static_cast(devAttrs_.channelCount) * devAttrs_.format; + DHLOGI("Init ashmem real sample size : %{public}d, length: %{public}d.", realSize, ashmemLength_); + int32_t ret = InitAshmem(ashmemLength_); + if (ret != HDF_SUCCESS) { + DHLOGE("Init ashmem error.."); + return HDF_FAILURE; + } + desc.memoryFd = fd_; + desc.transferFrameSize = static_cast(CalculateSampleNum(devAttrs_.sampleRate, timeInterval_)); + lengthPerTrans_ = desc.transferFrameSize * static_cast(devAttrs_.channelCount) * devAttrs_.format; + desc.isShareable = false; + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + ret = audioExtCallback_->RefreshAshmemInfo(renderId_, fd_, ashmemLength_, lengthPerTrans_); + if (ret != HDF_SUCCESS) { + DHLOGE("Refresh ashmem info failed."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetMmapPosition(uint64_t &frames, AudioTimeStamp &time) +{ + DHLOGI("Get mmap render position."); + if (audioExtCallback_ == nullptr) { + DHLOGE("Callback is nullptr."); + return HDF_FAILURE; + } + CurrentTime cTime; + int32_t ret = audioExtCallback_->ReadMmapPosition(renderId_, frames, cTime); + if (ret != HDF_SUCCESS) { + DHLOGE("Read mmap position failed."); + return HDF_FAILURE; + } + time.tvSec = cTime.tvSec; + time.tvNSec = cTime.tvNSec; + DHLOGI("Read mmap position. frames: %{public}" PRIu64", tvSec: %{public}" PRId64", tvNSec: %{public}" PRId64, + frames, cTime.tvSec, cTime.tvNSec); + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::AddAudioEffect(uint64_t effectid) +{ + DHLOGD("Add audio effect, not support yet."); + (void)effectid; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::RemoveAudioEffect(uint64_t effectid) +{ + DHLOGD("Remove audio effect, not support yet."); + (void)effectid; + return HDF_SUCCESS; +} + +int32_t AudioRenderExtImpl::GetFrameBufferSize(uint64_t &bufferSize) +{ + DHLOGD("Get frame buffer size, not support yet."); + (void)bufferSize; + return HDF_SUCCESS; +} + +const AudioDeviceDescriptor &AudioRenderExtImpl::GetRenderDesc() +{ + return devDesc_; +} + +void AudioRenderExtImpl::SetVolumeInner(const uint32_t vol) +{ + std::lock_guard volLck(volMtx_); + vol_ = vol; +} + +void AudioRenderExtImpl::SetVolumeRangeInner(const uint32_t volMax, const uint32_t volMin) +{ + std::lock_guard volLck(volMtx_); + volMin_ = volMin; + volMax_ = volMax; +} + +uint32_t AudioRenderExtImpl::GetVolumeInner() +{ + std::lock_guard volLck(volMtx_); + return vol_; +} + +uint32_t AudioRenderExtImpl::GetMaxVolumeInner() +{ + std::lock_guard volLck(volMtx_); + return volMax_; +} + +uint32_t AudioRenderExtImpl::GetMinVolumeInner() +{ + std::lock_guard volLck(volMtx_); + return volMin_; +} + +void AudioRenderExtImpl::SetAttrs(const std::string &adpName, const AudioDeviceDescriptor &desc, + const AudioSampleAttributes &attrs, const sptr &callback, const int32_t dhId) +{ + adapterName_ = adpName; + devDesc_ = desc; + devAttrs_ = attrs; + audioExtCallback_ = callback; + dhId_ = dhId; + if (attrs.type == AUDIO_MMAP_NOIRQ) { + timeInterval_ = AUDIO_MMAP_NOIRQ_INTERVAL; + } else if (attrs.type == AUDIO_MMAP_VOIP) { + timeInterval_ = AUDIO_MMAP_VOIP_INTERVAL; + } + devAttrs_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format, timeInterval_, true); + DHLOGI("Distributed lowlatency render set attrs, id(%{public}d). framesize(%{public}d)", + dhId_, devAttrs_.frameSize); +} + +void AudioRenderExtImpl::SetDumpFlagInner() +{ + DHLOGD("Set dump flag, not support yet."); +} + +AudioRenderInterfaceImplBase *GetRenderImplExt() +{ + DHLOGI("Get low latency render impl."); + static AudioRenderExtImpl *implBase = new AudioRenderExtImpl(); + if (implBase == nullptr) { + return nullptr; + } + return implBase; +} +} // namespace V1_0 +} // namespace Audio +} // namespace Distributedaudio +} // namespace HDI +} // namespace OHOS -- Gitee From 7ee97f5984aa5c29d5a9b129ed6ef82cde939995 Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Thu, 22 Aug 2024 06:49:28 +0000 Subject: [PATCH 0369/1485] setfunction modify Signed-off-by: yuzhiqiang --- usb/hdi_service/include/usbd_function.h | 6 +- usb/hdi_service/src/usb_interface_driver.cpp | 9 +- usb/hdi_service/src/usbd_function.cpp | 124 +++++++++++++++---- 3 files changed, 110 insertions(+), 29 deletions(-) diff --git a/usb/hdi_service/include/usbd_function.h b/usb/hdi_service/include/usbd_function.h index f9ced8167a..52f4a98e30 100644 --- a/usb/hdi_service/include/usbd_function.h +++ b/usb/hdi_service/include/usbd_function.h @@ -93,11 +93,13 @@ private: static int32_t SetFunctionToStorageHdc(); static int32_t SetFunctionToManufactureHdc(); static int32_t SetDDKFunction(uint32_t funcs); - static int32_t UsbdEnableDevice(); + static int32_t UsbdEnableDevice(int32_t funcs); static int32_t UsbdWaitUdc(); static int32_t UsbdWaitToNone(); static int32_t UsbdInitDDKFunction(uint32_t funcs); - static int32_t UsbdSetKernelFunction(int32_t kfuns); + static int32_t UsbdSetKernelFunction(int32_t kfuns, int32_t funcs); + static int32_t UsbdReadUdc(char* udcName, size_t len); + static int32_t UsbdWriteUdc(char* udcName, size_t len); static void UsbdUnregisterDevice(const std::string &serviceName); static int32_t UsbdRegisterDevice(const std::string &serviceName); static int32_t InitMtp(); diff --git a/usb/hdi_service/src/usb_interface_driver.cpp b/usb/hdi_service/src/usb_interface_driver.cpp index 581024df64..5f9d3b0c2a 100644 --- a/usb/hdi_service/src/usb_interface_driver.cpp +++ b/usb/hdi_service/src/usb_interface_driver.cpp @@ -36,6 +36,10 @@ struct HdfUsbInterfaceHost { static int32_t UsbInterfaceDriverDispatch( struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { + if (client == nullptr || client->device == nullptr || client->device->service == nullptr) { + HDF_LOGE("%{public}s:invalid param", __func__); + return HDF_ERR_INVALID_PARAM; + } OHOS::MessageParcel *dataParcel = nullptr; OHOS::MessageParcel *replyParcel = nullptr; OHOS::MessageOption option; @@ -49,11 +53,6 @@ static int32_t UsbInterfaceDriverDispatch( return HDF_ERR_INVALID_PARAM; } - if (client == nullptr || client->device == nullptr || client->device->service == nullptr) { - HDF_LOGE("%{public}s:invalid param", __func__); - return HDF_ERR_INVALID_PARAM; - } - auto *hdfUsbInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUsbInterfaceHost, ioService); if (hdfUsbInterfaceHost == nullptr || hdfUsbInterfaceHost->stub == nullptr) { HDF_LOGE("%{public}s:host or stub are nullptr", __func__); diff --git a/usb/hdi_service/src/usbd_function.cpp b/usb/hdi_service/src/usbd_function.cpp index f9a7a5ddda..0021283d44 100644 --- a/usb/hdi_service/src/usbd_function.cpp +++ b/usb/hdi_service/src/usbd_function.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "devmgr_hdi.h" #include "hdf_log.h" @@ -48,6 +49,7 @@ using GetMtpImplFunc = void*(*)(); constexpr uint32_t UDC_NAME_MAX_LEN = 32; constexpr int32_t WAIT_UDC_MAX_LOOP = 30; constexpr uint32_t WAIT_UDC_TIME = 100000; +constexpr int32_t WRITE_UDC_MAX_RETRY = 5; /* mtp and ptp use same driver and same service */ static std::string MTP_PTP_SERVICE_NAME {"usbfn_mtp_interface_service"}; #define UDC_PATH "/config/usb_gadget/g1/UDC" @@ -275,9 +277,9 @@ int32_t UsbdFunction::SetFunctionToNone() HDF_LOGE("%{public}s: release mtp failed", __func__); } } - UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); - UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); } + UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); + UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); int32_t ret = RemoveHdc(); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s: RemoveHdc error, ret = %{public}d", __func__, ret); @@ -313,27 +315,103 @@ int32_t UsbdFunction::SetDDKFunction(uint32_t funcs) return HDF_SUCCESS; } -int32_t UsbdFunction::UsbdEnableDevice() +int32_t UsbdFunction::UsbdWriteUdc(char* udcName, size_t len) +{ + FILE *fpWrite = fopen(UDC_PATH, "w"); + if (fpWrite == NULL) { + HDF_LOGE("%{public}s: fopen failed", __func__); + return HDF_ERR_BAD_FD; + } + + size_t count = fwrite(udcName, len, 1, fpWrite); + if (count != 1) { + HDF_LOGE("%{public}s: fwrite failed, errno: %{public}d", __func__, errno); + (void)fclose(fpWrite); + return HDF_FAILURE; + } + + if (ferror(fpWrite)) { + HDF_LOGW("%{public}s: fwrite failed, errno: %{public}d", __func__, errno); + } + if (fclose(fpWrite) == EOF) { + HDF_LOGE("%{public}s: flcose failed, errno: %{public}d", __func__, errno); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} +int32_t UsbdFunction::UsbdReadUdc(char* udcName, size_t len) { - FILE *fp = fopen(UDC_PATH, "w"); - if (fp == NULL) { + FILE *fpRead = fopen(UDC_PATH, "r"); + if (fpRead == NULL) { HDF_LOGE("%{public}s: fopen failed", __func__); return HDF_ERR_BAD_FD; } + size_t count = fread(udcName, len, 1, fpRead); + if (count != 1) { + if (feof(fpRead)) { + HDF_LOGI("%{public}s: fread end of file reached.", __func__); + } else if (ferror(fpRead)) { + HDF_LOGE("%{public}s: fread failed, errno: %{public}d", __func__, errno); + } else { + HDF_LOGW("%{public}s: fread len than expected", __func__); + } + return HDF_FAILURE; + } + + if (fclose(fpRead) == EOF) { + HDF_LOGW("%{public}s: flcose failed, errno: %{public}d", __func__, errno); + } + return HDF_SUCCESS; +} + +int32_t UsbdFunction::UsbdEnableDevice(int32_t funcs) +{ // get udc name char udcName[UDC_NAME_MAX_LEN] = {0}; int32_t ret = GetParameter("sys.usb.controller", "invalid", udcName, UDC_NAME_MAX_LEN); if (ret <= 0) { HDF_LOGE("%{public}s: GetParameter failed", __func__); - (void)fclose(fp); return HDF_FAILURE; } - size_t count = fwrite(udcName, strlen(udcName), 1, fp); - (void)fclose(fp); - if (count != 1) { - HDF_LOGE("%{public}s: fwrite failed", __func__); + char tmpName[UDC_NAME_MAX_LEN] = {0}; + for (int32_t i = 0; i < WRITE_UDC_MAX_RETRY; i++) { + if (i != 0) { + ret = SetDDKFunction(funcs); + if (ret != HDF_SUCCESS) { + UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); + UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); + } + usleep(WAIT_UDC_TIME); + continue; + } + ret = UsbdWriteUdc(udcName, strlen(udcName)); + if (ret != HDF_SUCCESS) { + UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); + UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); + usleep(WAIT_UDC_TIME); + continue; + } + + (void)memset_s(tmpName, UDC_NAME_MAX_LEN, 0, UDC_NAME_MAX_LEN); + ret = UsbdReadUdc(tmpName, strlen(udcName)); + if (ret != HDF_SUCCESS) { + UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); + UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); + usleep(WAIT_UDC_TIME); + continue; + } + + if (strcmp(udcName, tmpName) == 0) { + return HDF_SUCCESS; + } + HDF_LOGI("%{public}s: tmpName: %{public}s", __func__, tmpName); + usleep(WAIT_UDC_TIME); + } + + if (strcmp(udcName, tmpName) != 0) { + HDF_LOGE("%{public}s: strcmp failed", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -351,20 +429,17 @@ int32_t UsbdFunction::UsbdWaitUdc() char tmpName[UDC_NAME_MAX_LEN] = {0}; for (int32_t i = 0; i < WAIT_UDC_MAX_LOOP; i++) { - FILE *fp = fopen(UDC_PATH, "r"); - if (fp == NULL) { - HDF_LOGE("%{public}s: fopen failed", __func__); - return HDF_ERR_BAD_FD; - } - (void)memset_s(tmpName, UDC_NAME_MAX_LEN, 0, UDC_NAME_MAX_LEN); - if (fread(tmpName, strlen(udcName), 1, fp) != 1) { - HDF_LOGE("%{public}s: fread failed", __func__); + ret = UsbdReadUdc(tmpName, strlen(udcName)); + if (ret != HDF_SUCCESS) { + usleep(WAIT_UDC_TIME); + continue; } - (void)fclose(fp); + if (strcmp(udcName, tmpName) == 0) { return HDF_SUCCESS; } + HDF_LOGE("%{public}s: read UDC_PATH: %{public}s", __func__, tmpName); usleep(WAIT_UDC_TIME); } @@ -439,7 +514,7 @@ int32_t UsbdFunction::UsbdInitDDKFunction(uint32_t funcs) return HDF_SUCCESS; } -int32_t UsbdFunction::UsbdSetKernelFunction(int32_t kfuns) +int32_t UsbdFunction::UsbdSetKernelFunction(int32_t kfuns, int32_t funcs) { switch (kfuns) { case USB_FUNCTION_HDC: @@ -462,7 +537,7 @@ int32_t UsbdFunction::UsbdSetKernelFunction(int32_t kfuns) return UsbdFunction::SetFunctionToManufactureHdc(); default: HDF_LOGI("%{public}s: enable device", __func__); - return UsbdEnableDevice(); + return UsbdEnableDevice(funcs); } } @@ -479,12 +554,17 @@ int32_t UsbdFunction::UsbdSetFunction(uint32_t funcs) HDF_LOGW("%{public}s: setFunctionToNone error", __func__); } + if (funcs == USB_FUNCTION_NONE) { + HDF_LOGW("%{public}s: setFunctionToNone", __func__); + return HDF_SUCCESS; + } + if (UsbdFunction::SetDDKFunction(funcs)) { HDF_LOGE("%{public}s:SetDDKFunction error", __func__); return HDF_FAILURE; } - int32_t ret = UsbdSetKernelFunction(kfuns); + int32_t ret = UsbdSetKernelFunction(kfuns, funcs); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s, set kernel func failed", __func__); return HDF_FAILURE; -- Gitee From 99628afb544ba00e2c6b246902da152db1390e18 Mon Sep 17 00:00:00 2001 From: yangkan Date: Mon, 26 Aug 2024 08:22:12 +0000 Subject: [PATCH 0370/1485] update display/composer/test/moduletest/hdi_device_test.cpp. Signed-off-by: yangkan --- display/composer/test/moduletest/hdi_device_test.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/display/composer/test/moduletest/hdi_device_test.cpp b/display/composer/test/moduletest/hdi_device_test.cpp index fbe8379181..da0ce57c25 100644 --- a/display/composer/test/moduletest/hdi_device_test.cpp +++ b/display/composer/test/moduletest/hdi_device_test.cpp @@ -385,7 +385,9 @@ void DeviceTest::TearDown() void DeviceLayerDisplay::TearDown() { HdiTestDevice::GetInstance().Clear(); +#if !defined(DISPLAY_COMMUNITY) HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer(); +#endif } void VblankCtr::NotifyVblank(unsigned int sequence, uint64_t ns, const void* data) -- Gitee From d415a12e564f97a610a356e8043ea15b46487f0b Mon Sep 17 00:00:00 2001 From: fengyong Date: Mon, 26 Aug 2024 17:31:01 +0800 Subject: [PATCH 0371/1485] add hdf se tdd Signed-off-by: fengyong Signed-off-by: fengyong --- secure_element/test/unittest/BUILD.gn | 43 ++- secure_element/test/unittest/mock/mock.cpp | 110 ++++++++ secure_element/test/unittest/mock/mock.h | 59 ++++ .../unittest/se_impl_test/se_impl_test.cpp | 230 +++------------ .../se_vendor_adaptions_mock_test.cpp | 154 ++++++++++ .../se_vendor_adaptions_test.cpp | 263 ++++++++++++++++++ 6 files changed, 667 insertions(+), 192 deletions(-) create mode 100644 secure_element/test/unittest/mock/mock.cpp create mode 100644 secure_element/test/unittest/mock/mock.h create mode 100644 secure_element/test/unittest/se_vendor_adaptions_mock_test/se_vendor_adaptions_mock_test.cpp create mode 100644 secure_element/test/unittest/se_vendor_adaptions_test/se_vendor_adaptions_test.cpp diff --git a/secure_element/test/unittest/BUILD.gn b/secure_element/test/unittest/BUILD.gn index 568a0fcdd8..83dd4b615b 100644 --- a/secure_element/test/unittest/BUILD.gn +++ b/secure_element/test/unittest/BUILD.gn @@ -22,6 +22,7 @@ config("se_unit_test_config") { "$SE_DIR/hdi_service", "$SE_DIR/secure_element_ca_proxy", "$SE_DIR/vendor_adaptor", + "$SE_DIR/test/unittest/mock", ] cflags_cc = [ "-fexceptions" ] @@ -32,9 +33,10 @@ config("se_unit_test_config") { unit_test_deps = [ "$SE_DIR/hdi_service:libsecure_element_interface_service_1.0", "$SE_DIR/hdi_service:se_hdi_driver", - "$SE_DIR/secure_element_ca_proxy:secure_element_ca_proxy", "$SE_DIR/vendor_adaptor:se_vendor_adaptor", "../../../../interface/secure_element/v1_0:libsecure_element_proxy_1.0", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", ] unit_test_external_deps = [ @@ -64,8 +66,45 @@ ohos_unittest("se_impl_test") { subsystem_name = "hdf" } +ohos_unittest("se_vendor_adaptions_test") { + module_out_path = test_out_path + + sources = [ "se_vendor_adaptions_test/se_vendor_adaptions_test.cpp" ] + + configs = [ ":se_unit_test_config" ] + + deps = unit_test_deps + + external_deps = unit_test_external_deps + + part_name = "drivers_peripheral_secure_element" + subsystem_name = "hdf" +} + +ohos_unittest("se_vendor_adaptions_mock_test") { + module_out_path = test_out_path + + sources = [ + "$SE_DIR/test/unittest/mock/mock.cpp", + "se_vendor_adaptions_mock_test/se_vendor_adaptions_mock_test.cpp", + ] + + configs = [ ":se_unit_test_config" ] + + deps = unit_test_deps + + external_deps = unit_test_external_deps + + part_name = "drivers_peripheral_secure_element" + subsystem_name = "hdf" +} + group("hdf_se_unittest") { testonly = true - deps = [ ":se_impl_test" ] + deps = [ + ":se_impl_test", + ":se_vendor_adaptions_mock_test", + ":se_vendor_adaptions_test", + ] } diff --git a/secure_element/test/unittest/mock/mock.cpp b/secure_element/test/unittest/mock/mock.cpp new file mode 100644 index 0000000000..b1b514d51c --- /dev/null +++ b/secure_element/test/unittest/mock/mock.cpp @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "mock.h" + +namespace OHOS { +namespace HDI { +namespace SecureElement { + +int SecureElementCaProxy::VendorSecureElementCaOnStart() const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaOnStart(); +} + +int SecureElementCaProxy::VendorSecureElementCaInit() const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaInit(); +} + +int SecureElementCaProxy::VendorSecureElementCaUninit() const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaUninit(); +} + +int SecureElementCaProxy::VendorSecureElementCaGetAtr(uint8_t *rsp, uint32_t *rspLen) const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaGetAtr(rsp, rspLen); +} + +int SecureElementCaProxy::VendorSecureElementCaOpenLogicalChannel(uint8_t *aid, uint32_t len, uint8_t p2, + uint8_t *rsp, uint32_t *rspLen, uint32_t *channelNum) const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaOpenLogicalChannel(aid, len, p2, rsp, rspLen, channelNum); +} + +int SecureElementCaProxy::VendorSecureElementCaOpenBasicChannel(uint8_t *aid, uint32_t len, uint8_t *rsp, + uint32_t *rspLen) const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaOpenBasicChannel(aid, len, rsp, rspLen); +} + +int SecureElementCaProxy::VendorSecureElementCaCloseChannel(uint32_t channelNum) const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaCloseChannel(channelNum); +} + +int SecureElementCaProxy::VendorSecureElementCaTransmit(uint8_t *cmd, uint32_t cmdLen, uint8_t *rsp, + uint32_t *rspLen) const +{ + auto p = MockTee::GetMockTee(); + if (!p) { + return 0; + } + return p->VendorSecureElementCaTransmit(cmd, cmdLen, rsp, rspLen); +} +SecureElementCaProxy::DynamicLoad::DynamicLoad(const std::string &lib) {} + +SecureElementCaProxy::DynamicLoad::~DynamicLoad() {} + +bool SecureElementCaProxy::DynamicLoad::LoadLib() +{ + return false; +} + +bool SecureElementCaProxy::DynamicLoad::CloseLib() +{ + return false; +} +} // SecureElement +} // HDI +} // OHOS \ No newline at end of file diff --git a/secure_element/test/unittest/mock/mock.h b/secure_element/test/unittest/mock/mock.h new file mode 100644 index 0000000000..d98caf908e --- /dev/null +++ b/secure_element/test/unittest/mock/mock.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MOCK_VENDOR_ADAPTIONS_H +#define MOCK_VENDOR_ADAPTIONS_H + +#include +#include +#include "secure_element_ca_proxy.h" + +namespace OHOS { +namespace HDI { +namespace SecureElement { +class MockTee { +public: + static void SetMockTee(MockTee &object) + { + obj = &object; + } + + static void ResetMockTee() + { + obj = nullptr; + } + + static MockTee *GetMockTee() + { + return obj; + } + MOCK_METHOD(int, VendorSecureElementCaOnStart, (), ()); + MOCK_METHOD(int, VendorSecureElementCaInit, (), ()); + MOCK_METHOD(int, VendorSecureElementCaUninit, (), ()); + MOCK_METHOD(int, VendorSecureElementCaGetAtr, (uint8_t *rsp, uint32_t *rspLen), ()); + MOCK_METHOD(int, VendorSecureElementCaOpenLogicalChannel, (uint8_t *aid, uint32_t len, uint8_t p2, + uint8_t *rsp, uint32_t *rspLen, uint32_t *channelNum), ()); + MOCK_METHOD(int, VendorSecureElementCaOpenBasicChannel, (uint8_t *aid, uint32_t len, uint8_t *rsp, + uint32_t *rspLen), ()); + MOCK_METHOD(int, VendorSecureElementCaCloseChannel, (uint32_t channelNum), ()); + MOCK_METHOD(int, VendorSecureElementCaTransmit, (uint8_t *cmd, uint32_t cmdLen, uint8_t *rsp, + uint32_t *rspLen), ()); +private: + inline static MockTee *obj = nullptr; +}; +} // SecureElement +} // HDI +} // OHOS + +#endif // MOCK_VENDOR_ADAPTIONS_H diff --git a/secure_element/test/unittest/se_impl_test/se_impl_test.cpp b/secure_element/test/unittest/se_impl_test/se_impl_test.cpp index dc5ff31570..616dab22d5 100644 --- a/secure_element/test/unittest/se_impl_test/se_impl_test.cpp +++ b/secure_element/test/unittest/se_impl_test/se_impl_test.cpp @@ -18,44 +18,16 @@ #include #include #include +#include #include "se_impl.h" -#include "v1_0/isecure_element_interface.h" -#include "v1_0/secure_element_types.h" -#include "v1_0/isecure_element_callback.h" namespace OHOS { namespace HDI { +namespace SecureElement { namespace TEST { +using namespace testing; using namespace testing::ext; -using ISeHdiV1_0 = OHOS::HDI::SecureElement::V1_0::ISecureElementInterface; -using OHOS::HDI::SecureElement::V1_0::SecureElementStatus; -using OHOS::HDI::SecureElement::V1_0::ISecureElementCallback; -using namespace OHOS::HDI::SecureElement::V1_0; - -// the max APDU response bytes -static constexpr const uint16_t MAX_APDU_RESP_BYTES = 512; -static constexpr const uint8_t HEX_BYTE_LEN = 2; - -static void HexStringToBytesArray(const std::string &src, std::vector &bytes) -{ - // convert hex string to byte array - if (src.empty()) { - return; - } - - uint32_t bytesLen = src.length() / HEX_BYTE_LEN; - std::string strByte; - unsigned int srcIntValue; - for (uint32_t i = 0; i < bytesLen; i++) { - strByte = src.substr(i * HEX_BYTE_LEN, HEX_BYTE_LEN); - if (sscanf_s(strByte.c_str(), "%x", &srcIntValue) <= 0) { - bytes.clear(); - return; - } - bytes.push_back(static_cast(srcIntValue & 0xFF)); - } -} class SeImplTest : public testing::Test { public: @@ -65,35 +37,24 @@ public: void TearDown(); }; -class SeClientCallback : public ISecureElementCallback { -public: - explicit SeClientCallback() { - } - - int32_t OnSeStateChanged(bool connected) override - { - return HDF_SUCCESS; - } -}; - void SeImplTest::SetUpTestCase() { - std::cout << " SetUpTestCase SeImplTest." << std::endl; + HDF_LOGD("SetUpTestCase SeImplTest"); } void SeImplTest::TearDownTestCase() { - std::cout << " TearDownTestCase SeImplTest." << std::endl; + HDF_LOGD("TearDownTestCase SeImplTest"); } void SeImplTest::SetUp() { - std::cout << " SetUp SeImplTest." << std::endl; + HDF_LOGD("SetUp SeImplTest"); } void SeImplTest::TearDown() { - std::cout << " TearDown SeImplTest." << std::endl; + HDF_LOGD("TearDown SeImplTest"); } /** @@ -104,26 +65,12 @@ void SeImplTest::TearDown() HWTEST_F(SeImplTest, init001, TestSize.Level1) { const sptr clientCallback = nullptr; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->init(clientCallback, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->init(clientCallback, status); ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); } -/** - * @tc.name: init002 - * @tc.desc: Test SeImplTest init. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, init002, TestSize.Level1) -{ - const sptr clientCallback = new SeClientCallback(); - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->init(clientCallback, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - /** * @tc.name: getAtr001 * @tc.desc: Test SeImplTest getAtr. @@ -131,22 +78,9 @@ HWTEST_F(SeImplTest, init002, TestSize.Level1) */ HWTEST_F(SeImplTest, getAtr001, TestSize.Level1) { - std::vector vecResponse(MAX_APDU_RESP_BYTES, 0); - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->getAtr(vecResponse); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: getAtr002 - * @tc.desc: Test SeImplTest getAtr. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, getAtr002, TestSize.Level1) -{ - std::vector vecResponse; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->getAtr(vecResponse); + std::vector response; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->getAtr(response); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -158,8 +92,8 @@ HWTEST_F(SeImplTest, getAtr002, TestSize.Level1) HWTEST_F(SeImplTest, isSecureElementPresent001, TestSize.Level1) { bool present = false; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->isSecureElementPresent(present); + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->isSecureElementPresent(present); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -170,13 +104,13 @@ HWTEST_F(SeImplTest, isSecureElementPresent001, TestSize.Level1) */ HWTEST_F(SeImplTest, openLogicalChannel001, TestSize.Level1) { - const std::vector aid; + std::vector aid; uint8_t p2 = 0; std::vector response; uint8_t channelNumber = 0; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openLogicalChannel(aid, p2, response, channelNumber, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->openLogicalChannel(aid, p2, response, channelNumber, status); ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); } @@ -187,32 +121,13 @@ HWTEST_F(SeImplTest, openLogicalChannel001, TestSize.Level1) */ HWTEST_F(SeImplTest, openLogicalChannel002, TestSize.Level1) { - const std::vector aid = {0x001}; + std::vector aid = {0x001, 0x002, 0x003}; uint8_t p2 = 0; std::vector response; uint8_t channelNumber = 0; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openLogicalChannel(aid, p2, response, channelNumber, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: openLogicalChannel003 - * @tc.desc: Test SeImplTest openLogicalChannel. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, openLogicalChannel003, TestSize.Level1) -{ - std::string aidStr = "a000000151000000"; - std::vector aid; - HexStringToBytesArray(aidStr, aid); - uint8_t p2 = 127; - std::vector response(MAX_APDU_RESP_BYTES, 0); - uint8_t channelNumber = 0; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openLogicalChannel(aid, p2, response, channelNumber, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->openLogicalChannel(aid, p2, response, channelNumber, status); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -226,9 +141,9 @@ HWTEST_F(SeImplTest, openBasicChannel001, TestSize.Level1) const std::vector aid; uint8_t p2 = 0; std::vector response; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openBasicChannel(aid, p2, response, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->openBasicChannel(aid, p2, response, status); ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM); } @@ -239,30 +154,12 @@ HWTEST_F(SeImplTest, openBasicChannel001, TestSize.Level1) */ HWTEST_F(SeImplTest, openBasicChannel002, TestSize.Level1) { - const std::vector aid = {0x001}; + const std::vector aid = {0x001, 0x002, 0x003}; uint8_t p2 = 0; std::vector response; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openBasicChannel(aid, p2, response, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: openBasicChannel003 - * @tc.desc: Test SeImplTest openBasicChannel. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, openBasicChannel003, TestSize.Level1) -{ - std::string aidStr = "a000000151000000"; - std::vector aid; - HexStringToBytesArray(aidStr, aid); - uint8_t p2 = 127; - std::vector response(MAX_APDU_RESP_BYTES, 0); - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->openBasicChannel(aid, p2, response, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->openBasicChannel(aid, p2, response, status); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -274,23 +171,9 @@ HWTEST_F(SeImplTest, openBasicChannel003, TestSize.Level1) HWTEST_F(SeImplTest, closeChannel001, TestSize.Level1) { uint8_t channelNumber = 0; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->closeChannel(channelNumber, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: closeChannel002 - * @tc.desc: Test SeImplTest closeChannel. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, closeChannel002, TestSize.Level1) -{ - uint8_t channelNumber = 1; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->closeChannel(channelNumber, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->closeChannel(channelNumber, status); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -303,43 +186,9 @@ HWTEST_F(SeImplTest, transmit001, TestSize.Level1) { const std::vector command; std::vector response; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->transmit(command, response, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: transmit002 - * @tc.desc: Test SeImplTest transmit. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, transmit002, TestSize.Level1) -{ - std::string cmdStr = "80CA9F7F00"; - std::vector command; - HexStringToBytesArray(cmdStr, command); - std::vector response; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->transmit(command, response, status); - ASSERT_TRUE(ret == HDF_SUCCESS); -} - -/** - * @tc.name: transmit003 - * @tc.desc: Test SeImplTest transmit. - * @tc.type: FUNC - */ -HWTEST_F(SeImplTest, transmit003, TestSize.Level1) -{ - std::string cmdStr = "81CA9F7F00"; - std::vector command; - HexStringToBytesArray(cmdStr, command); - std::vector response; - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->transmit(command, response, status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->transmit(command, response, status); ASSERT_TRUE(ret == HDF_SUCCESS); } @@ -350,11 +199,12 @@ HWTEST_F(SeImplTest, transmit003, TestSize.Level1) */ HWTEST_F(SeImplTest, reset001, TestSize.Level1) { - SecureElementStatus status = SecureElementStatus::SE_GENERAL_ERROR; - OHOS::sptr seHdiInterface_ = ISeHdiV1_0::Get(); - int ret = seHdiInterface_->reset(status); + SecureElementStatus status; + std::shared_ptr seImpl = std::make_shared(); + int ret = seImpl->reset(status); ASSERT_TRUE(ret == HDF_SUCCESS); } } } +} } \ No newline at end of file diff --git a/secure_element/test/unittest/se_vendor_adaptions_mock_test/se_vendor_adaptions_mock_test.cpp b/secure_element/test/unittest/se_vendor_adaptions_mock_test/se_vendor_adaptions_mock_test.cpp new file mode 100644 index 0000000000..45b6295b78 --- /dev/null +++ b/secure_element/test/unittest/se_vendor_adaptions_mock_test/se_vendor_adaptions_mock_test.cpp @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include +#include +#include +#include + +#include "se_impl.h" +#include "se_vendor_adaptions.h" +#include "mock.h" + +namespace OHOS { +namespace HDI { +namespace SecureElement { +namespace TEST { +using namespace testing; +using namespace testing::ext; + +class SeVendorAdaptionsTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + MockTee mockTee_; +}; + +void SeVendorAdaptionsTest::SetUpTestCase() +{ + HDF_LOGD("SetUpTestCase SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::TearDownTestCase() +{ + HDF_LOGD("TearDownTestCase SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::SetUp() +{ + MockTee::SetMockTee(mockTee_); + HDF_LOGD("SetUp SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::TearDown() +{ + MockTee::ResetMockTee(); + HDF_LOGD("TearDown SeVendorAdaptionsTest"); +} + +/** + * @tc.name: getAtr001 + * @tc.desc: Test SeVendorAdaptionsTest getAtr. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getAtr001, TestSize.Level1) +{ + std::vector response = {0x01, 0x02, 0x03}; + EXPECT_CALL(mockTee_, VendorSecureElementCaGetAtr(_, _)) + .WillOnce(Return(0)); + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->getAtr(response); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: openLogicalChannel002 + * @tc.desc: Test SeVendorAdaptionsTest openLogicalChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, openLogicalChannel002, TestSize.Level1) +{ + std::vector aid = {0x001, 0x002, 0x003}; + uint8_t p2 = 0; + std::vector response; + uint8_t channelNumber = 0; + SecureElementStatus status; + EXPECT_CALL(mockTee_, VendorSecureElementCaOpenLogicalChannel(_, _, _, _, _, _)) + .WillOnce(Return(0)); + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->openLogicalChannel(aid, p2, response, channelNumber, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: openBasicChannel002 + * @tc.desc: Test SeVendorAdaptionsTest openBasicChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, openBasicChannel002, TestSize.Level1) +{ + EXPECT_CALL(mockTee_, VendorSecureElementCaOpenBasicChannel(_, _, _, _)) + .WillOnce(Return(0)); + const std::vector aid = {0x001, 0x002, 0x003}; + uint8_t p2 = 0; + std::vector response; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->openBasicChannel(aid, p2, response, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: closeChannel001 + * @tc.desc: Test SeVendorAdaptionsTest closeChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, closeChannel001, TestSize.Level1) +{ + EXPECT_CALL(mockTee_, VendorSecureElementCaCloseChannel(_)) + .WillOnce(Return(0)); + EXPECT_CALL(mockTee_, VendorSecureElementCaUninit()) + .WillOnce(Return(0)); + uint8_t channelNumber = 0; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->closeChannel(channelNumber, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: transmit001 + * @tc.desc: Test SeVendorAdaptionsTest transmit. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, transmit001, TestSize.Level1) +{ + EXPECT_CALL(mockTee_, VendorSecureElementCaTransmit(_, _, _, _)) + .WillOnce(Return(0)); + const std::vector command; + std::vector response; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->transmit(command, response, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} +} +} +} +} \ No newline at end of file diff --git a/secure_element/test/unittest/se_vendor_adaptions_test/se_vendor_adaptions_test.cpp b/secure_element/test/unittest/se_vendor_adaptions_test/se_vendor_adaptions_test.cpp new file mode 100644 index 0000000000..e0372d6a7e --- /dev/null +++ b/secure_element/test/unittest/se_vendor_adaptions_test/se_vendor_adaptions_test.cpp @@ -0,0 +1,263 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include +#include +#include +#include + +#include "se_impl.h" +#include "se_vendor_adaptions.h" + +namespace OHOS { +namespace HDI { +namespace SecureElement { +namespace TEST { +using namespace testing; +using namespace testing::ext; + +class SeVendorAdaptionsTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void SeVendorAdaptionsTest::SetUpTestCase() +{ + HDF_LOGD("SetUpTestCase SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::TearDownTestCase() +{ + HDF_LOGD("TearDownTestCase SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::SetUp() +{ + HDF_LOGD("SetUp SeVendorAdaptionsTest"); +} + +void SeVendorAdaptionsTest::TearDown() +{ + HDF_LOGD("TearDown SeVendorAdaptionsTest"); +} + +/** + * @tc.name: getAtr001 + * @tc.desc: Test SeVendorAdaptionsTest getAtr. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getAtr001, TestSize.Level1) +{ + std::vector response; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->getAtr(response); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: openLogicalChannel002 + * @tc.desc: Test SeVendorAdaptionsTest openLogicalChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, openLogicalChannel002, TestSize.Level1) +{ + std::vector aid = {0x001, 0x002, 0x003}; + uint8_t p2 = 0; + std::vector response; + uint8_t channelNumber = 0; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->openLogicalChannel(aid, p2, response, channelNumber, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: openBasicChannel002 + * @tc.desc: Test SeVendorAdaptionsTest openBasicChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, openBasicChannel002, TestSize.Level1) +{ + const std::vector aid = {0x001, 0x002, 0x003}; + uint8_t p2 = 0; + std::vector response; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->openBasicChannel(aid, p2, response, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: closeChannel001 + * @tc.desc: Test SeVendorAdaptionsTest closeChannel. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, closeChannel001, TestSize.Level1) +{ + uint8_t channelNumber = 0; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->closeChannel(channelNumber, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: transmit001 + * @tc.desc: Test SeVendorAdaptionsTest transmit. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, transmit001, TestSize.Level1) +{ + const std::vector command; + std::vector response; + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->transmit(command, response, status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: reset001 + * @tc.desc: Test SeVendorAdaptionsTest reset. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, reset001, TestSize.Level1) +{ + SecureElementStatus status; + std::shared_ptr seVendorAdaptions = std::make_shared(); + int ret = seVendorAdaptions->reset(status); + ASSERT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: getStatusBySW001 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW001, TestSize.Level1) +{ + uint8_t sw1 = 0x62; + uint8_t sw2 = 0; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_SUCCESS); +} + +/** + * @tc.name: getStatusBySW002 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW002, TestSize.Level1) +{ + uint8_t sw1 = 0x63; + uint8_t sw2 = 0; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_SUCCESS); +} + +/** + * @tc.name: getStatusBySW003 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW003, TestSize.Level1) +{ + uint8_t sw1 = 0x90; + uint8_t sw2 = 0x00; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_SUCCESS); +} + +/** + * @tc.name: getStatusBySW004 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW004, TestSize.Level1) +{ + uint8_t sw1 = 0x6A; + uint8_t sw2 = 0x82; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_NO_SUCH_ELEMENT_ERROR); +} + +/** + * @tc.name: getStatusBySW005 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW005, TestSize.Level1) +{ + uint8_t sw1 = 0x69; + uint8_t sw2 = 0x99; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_NO_SUCH_ELEMENT_ERROR); +} + +/** + * @tc.name: getStatusBySW006 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW006, TestSize.Level1) +{ + uint8_t sw1 = 0x69; + uint8_t sw2 = 0x85; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_NO_SUCH_ELEMENT_ERROR); +} + +/** + * @tc.name: getStatusBySW007 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW007, TestSize.Level1) +{ + uint8_t sw1 = 0x6A; + uint8_t sw2 = 0x86; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_OPERATION_NOT_SUPPORTED_ERROR); +} + +/** + * @tc.name: getStatusBySW008 + * @tc.desc: Test SeVendorAdaptionsTest getStatusBySW. + * @tc.type: FUNC + */ +HWTEST_F(SeVendorAdaptionsTest, getStatusBySW008, TestSize.Level1) +{ + uint8_t sw1 = 0; + uint8_t sw2 = 0; + std::shared_ptr seVendorAdaptions = std::make_shared(); + SecureElementStatus ret = seVendorAdaptions->getStatusBySW(sw1, sw2); + ASSERT_TRUE(ret == SecureElementStatus::SE_GENERAL_ERROR); +} +} +} +} +} \ No newline at end of file -- Gitee From 5c97afd3cdc09d857572aee6b13f6bdbfa64efff Mon Sep 17 00:00:00 2001 From: zhanghang133 Date: Mon, 26 Aug 2024 14:54:45 +0800 Subject: [PATCH 0372/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhanghang133 --- camera/BUILD.gn | 5 ---- camera/test/BUILD.gn | 7 ------ .../camera_device/camera_device_fuzzer.cpp | 23 +++++++++++-------- camera/test/fuzztest/common/include/common.h | 3 +++ .../ut/pipeline_core/pipeline_core_test.cpp | 4 ++-- 5 files changed, 19 insertions(+), 23 deletions(-) diff --git a/camera/BUILD.gn b/camera/BUILD.gn index ac117454ee..d5dad64f4b 100644 --- a/camera/BUILD.gn +++ b/camera/BUILD.gn @@ -62,14 +62,9 @@ if (defined(ohos_lite)) { # acceptance unit test "test/hdi/metadata_test:camera_metadata_operator_ut", "test/hdi/v1_0:camera_test_at", - "test/hdi/v1_1:camera_test_hdi_V1_1", - "test/hdi/v1_2:camera_test_hdi_V1_2", - "test/hdi/v1_3:camera_test_hdi_V1_3", # benchmark test "test/benchmarktest/v1_0:hdf_camera_benchmark_test", - "test/benchmarktest/v1_1:hdf_camera_benchmark_test_v1_1", - "test/benchmarktest/v1_2:hdf_camera_benchmark_test_v1_2", # v4l2 unit test "test/ut/v4l2:camera_test_v4l2_ut", diff --git a/camera/test/BUILD.gn b/camera/test/BUILD.gn index 0df525c7b9..53fbf1ba62 100644 --- a/camera/test/BUILD.gn +++ b/camera/test/BUILD.gn @@ -20,17 +20,10 @@ group("camera_hal_test") { } else { deps = [ "$test_path/benchmarktest/v1_0:hdf_camera_benchmark_test", - "$test_path/benchmarktest/v1_1:hdf_camera_benchmark_test_v1_1", - "$test_path/benchmarktest/v1_2:hdf_camera_benchmark_test_v1_2", "$test_path/demo_3A:ohos_camera_3a_demo", - "$test_path/fuzztest/metadata_operator:metadata_operator_fuzztest", - "$test_path/fuzztest/metadata_utils:metadata_utils_fuzztest", "$test_path/hdi/metadata_test:camera_metadata_operator_ut", "$test_path/hdi/sequenceable_test:camera_hdi_sequenceable_ut", "$test_path/hdi/v1_0:camera_test_at", - "$test_path/hdi/v1_1:camera_test_hdi_V1_1", - "$test_path/hdi/v1_2:camera_test_hdi_V1_2", - "$test_path/hdi/v1_3:camera_test_hdi_V1_3", "$test_path/ut/buffer_manager:camera_buffer_manager_ut", "$test_path/ut/usb_camera:camera_usb_test_ut", "$test_path/ut/v4l2:camera_test_v4l2_ut", diff --git a/camera/test/fuzztest/camera_device/camera_device_fuzzer.cpp b/camera/test/fuzztest/camera_device/camera_device_fuzzer.cpp index 4db04c2754..8f6f4a7f06 100644 --- a/camera/test/fuzztest/camera_device/camera_device_fuzzer.cpp +++ b/camera/test/fuzztest/camera_device/camera_device_fuzzer.cpp @@ -59,10 +59,13 @@ void FuncUpdateSettings(const uint8_t *rawData, size_t size) if (size >= RAW_DATA_SIZE_MAX) { return; } - std::vector abilityVec = {}; - uint8_t *data = const_cast(rawData); - abilityVec.push_back(*data); - cameraTest->cameraDeviceV1_1->UpdateSettings(abilityVec); + float *data = const_cast(reinterpret_cast(rawData)); + std::shared_ptr meta = std::make_shared( + cameraTest->itemCapacity, cameraTest->dataCapacity); + meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &data[0], cameraTest->dataCount); + std::vector metaVec; + Camera::MetadataUtils::ConvertMetadataToVec(meta, metaVec); + cameraTest->cameraDeviceV1_1->UpdateSettings(metaVec); } void FuncSetResultMode(const uint8_t *rawData, size_t size) @@ -102,15 +105,17 @@ void FuncDisableResult(const uint8_t *rawData, size_t size) void FuncGetStatus(const uint8_t *rawData, size_t size) { (void)size; - std::vector result = {}; std::vector resultOut = {}; - uint8_t *data = const_cast(reinterpret_cast(rawData)); - result.push_back(*data); - + float *data = const_cast(reinterpret_cast(rawData)); + std::shared_ptr meta = std::make_shared( + cameraTest->itemCapacity, cameraTest->dataCapacity); + meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &data[0], cameraTest->dataCount); + std::vector metaVec; + Camera::MetadataUtils::ConvertMetadataToVec(meta, metaVec); if (nullptr == cameraTest->cameraDeviceV1_2) { return; } - cameraTest->cameraDeviceV1_2->GetStatus(result, resultOut); + cameraTest->cameraDeviceV1_2->GetStatus(metaVec, resultOut); } void FuncGetSecureCameraSeq(const uint8_t *rawData, size_t size) diff --git a/camera/test/fuzztest/common/include/common.h b/camera/test/fuzztest/common/include/common.h index ed34e863ed..eb245c87a1 100644 --- a/camera/test/fuzztest/common/include/common.h +++ b/camera/test/fuzztest/common/include/common.h @@ -177,6 +177,9 @@ public: std::vector captureIds; std::vector streamIds; int32_t imageDataSaveSwitch = SWITCH_OFF; + uint32_t itemCapacity = 100; + uint32_t dataCapacity = 2000; + uint32_t dataCount = 1; int32_t rc; bool status; diff --git a/camera/test/ut/pipeline_core/pipeline_core_test.cpp b/camera/test/ut/pipeline_core/pipeline_core_test.cpp index aa8fbfefac..b8ef6cd7c4 100644 --- a/camera/test/ut/pipeline_core/pipeline_core_test.cpp +++ b/camera/test/ut/pipeline_core/pipeline_core_test.cpp @@ -225,8 +225,8 @@ HWTEST_F(PipelineCoreTest, PipelineCore_AbNormalPreviewTest, TestSize.Level0) EXPECT_TRUE(s != nullptr); re = s->Init(cameraId_); EXPECT_TRUE(re == RC_OK); - re = s->CreatePipeline(2); // unsupportted mode - EXPECT_TRUE(re != RC_OK); + re = s->CreatePipeline(2); + EXPECT_TRUE(re == RC_OK); } HWTEST_F(PipelineCoreTest, PipelineCore_NormalPreviewSnapshotSingleConfigTest, TestSize.Level0) -- Gitee From 61ba066c177b8a598285e4d496a35bd8fb525046 Mon Sep 17 00:00:00 2001 From: w30042960 Date: Mon, 26 Aug 2024 19:31:48 +0800 Subject: [PATCH 0373/1485] add gn Signed-off-by: w30042960 --- .../hdi_service/audio/v1_0/BUILD.gn | 14 +--- .../audio/v1_0/test/unittest/BUILD.gn | 4 +- .../unittest/audio_capture_extension/BUILD.gn | 68 +++++++++++++++++++ .../unittest/audio_render_extension/BUILD.gn | 68 +++++++++++++++++++ 4 files changed, 141 insertions(+), 13 deletions(-) create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/BUILD.gn create mode 100644 distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/BUILD.gn diff --git a/distributed_audio/hdi_service/audio/v1_0/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/BUILD.gn index 277fb8b080..5712458c48 100644 --- a/distributed_audio/hdi_service/audio/v1_0/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/BUILD.gn @@ -22,25 +22,15 @@ ohos_shared_library("libaudio_manager_daudio_primary_service_1.0") { "${hdf_service_path}/hdi_service/common/utils/include", ] - if (drivers_peripheral_distributed_audio_extension) { - include_dirs += - [ "${distributedaudio_ext_path}/hdf_service_extension/include/" ] - } - sources = [ "./src/audio_adapter_interface_impl.cpp", + "./src/audio_capture_ext_impl.cpp", "./src/audio_capture_interface_impl.cpp", "./src/audio_manager_interface_impl.cpp", + "./src/audio_render_ext_impl.cpp", "./src/audio_render_interface_impl.cpp", ] - if (drivers_peripheral_distributed_audio_extension) { - sources += [ - "${distributedaudio_ext_path}/hdf_service_extension/src/audio_capture_ext_impl.cpp", - "${distributedaudio_ext_path}/hdf_service_extension/src/audio_render_ext_impl.cpp", - ] - } - public_deps = [ "${hdf_service_path}/hdi_service/common:libdaudio_hdf_utils" ] external_deps = [ diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/BUILD.gn index be3662072b..98e3da1e49 100644 --- a/distributed_audio/hdi_service/audio/v1_0/test/unittest/BUILD.gn +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2023 Huawei Device Co., Ltd. +# Copyright (c) 2023-2024 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -18,8 +18,10 @@ group("hdi_service_audio_test") { testonly = true deps = [ "${hdf_ser_aud_path}/test/unittest/audio_adapter_interface:hdi_service_audio_adapter_test", + "${hdf_ser_aud_path}/test/unittest/audio_capture_extension:hdi_service_audio_capture_ext_test", "${hdf_ser_aud_path}/test/unittest/audio_capture_interface:hdi_service_audio_capture_test", "${hdf_ser_aud_path}/test/unittest/audio_manager_interface:hdi_service_audio_manager_test", + "${hdf_ser_aud_path}/test/unittest/audio_render_extension:hdi_service_audio_Render_ext_test", "${hdf_ser_aud_path}/test/unittest/audio_render_interface:hdi_service_audio_render_test", ] } diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/BUILD.gn new file mode 100644 index 0000000000..c326f9a064 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_capture_extension/BUILD.gn @@ -0,0 +1,68 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../distributedaudio.gni") + +module_out_path = "distributed_audio/hdf_service/hdi_service/audio" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "${hdf_ser_aud_path}/include", + "${hdf_ser_aud_path}/test/unittest/audio_test_utils", + "${hdf_service_path}/hdi_service/common/include", + "${hdf_service_path}/hdi_service/common/log/include", + "${hdf_service_path}/hdi_service/common/utils/include", + ] +} + +## UnitTest hdi_service_audio_v1_0_test +ohos_unittest("HDIServiceAudioCaptureExtTest") { + module_out_path = module_out_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-Dprivate=public", + "-Dprotected=public", + ] + + sources = [ "${hdf_ser_aud_path}/test/unittest/audio_capture_extension/src/audio_capture_ext_impl_test.cpp" ] + + configs = [ ":module_private_config" ] + + public_deps = + [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0" ] + + external_deps = [ + "cJSON:cjson", + "c_utils:utils", + "drivers_interface_distributed_audio:libdaudio_stub_1.0", + "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", + "hilog:libhilog", + "ipc:ipc_core", + ] +} + +group("hdi_service_audio_capture_ext_test") { + testonly = true + deps = [ ":HDIServiceAudioCaptureExtTest" ] +} diff --git a/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/BUILD.gn b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/BUILD.gn new file mode 100644 index 0000000000..94ac8b5ad7 --- /dev/null +++ b/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_render_extension/BUILD.gn @@ -0,0 +1,68 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/components/hdi/hdi.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("../../../../../../distributedaudio.gni") + +module_out_path = "distributed_audio/hdf_service/hdi_service/audio" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "${hdf_ser_aud_path}/include", + "${hdf_ser_aud_path}/test/unittest/audio_test_utils", + "${hdf_service_path}/hdi_service/common/include", + "${hdf_service_path}/hdi_service/common/log/include", + "${hdf_service_path}/hdi_service/common/utils/include", + ] +} + +## UnitTest hdi_service_audio_v1_0_test +ohos_unittest("HDIServiceAudioRenderExtTest") { + module_out_path = module_out_path + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-Dprivate=public", + "-Dprotected=public", + ] + + sources = [ "${hdf_ser_aud_path}/test/unittest/audio_render_extension/src/audio_render_ext_impl_test.cpp" ] + + configs = [ ":module_private_config" ] + + public_deps = + [ "${hdf_ser_aud_path}:libaudio_manager_daudio_primary_service_1.0" ] + + external_deps = [ + "cJSON:cjson", + "c_utils:utils", + "drivers_interface_distributed_audio:libdaudio_stub_1.0", + "drivers_interface_distributed_audio:libdaudioext_stub_2.0", + "googletest:gmock", + "hilog:libhilog", + "ipc:ipc_core", + ] +} + +group("hdi_service_audio_Render_ext_test") { + testonly = true + deps = [ ":HDIServiceAudioRenderExtTest" ] +} -- Gitee From 4ad8c72c0ee02c77dcef6d7dce1f4d0299e042e8 Mon Sep 17 00:00:00 2001 From: hwyml Date: Mon, 26 Aug 2024 19:52:09 +0800 Subject: [PATCH 0374/1485] optimize close device Signed-off-by: hwyml Change-Id: I351e562938766276d476eee26f7876256596ceea --- usb/ddk/host/include/usb_interface_pool.h | 1 + usb/ddk/host/src/usb_interface_pool.c | 7 +++++-- usb/ddk/host/src/usb_io_manage.c | 16 +++++++++++++--- usb/hdi_service/src/usb_impl.cpp | 8 -------- 4 files changed, 19 insertions(+), 13 deletions(-) diff --git a/usb/ddk/host/include/usb_interface_pool.h b/usb/ddk/host/include/usb_interface_pool.h index 122cbf4b46..356a86585e 100644 --- a/usb/ddk/host/include/usb_interface_pool.h +++ b/usb/ddk/host/include/usb_interface_pool.h @@ -80,6 +80,7 @@ struct UsbInterfacePool { UsbPoolProcessStatusType ioRecvProcessStopStatus; struct OsalMutex ioStopLock; struct UsbDevice *device; + struct OsalSem ioSem; }; struct UsbPipeQueryPara { diff --git a/usb/ddk/host/src/usb_interface_pool.c b/usb/ddk/host/src/usb_interface_pool.c index 1b1d16d706..bfb4cf13cd 100644 --- a/usb/ddk/host/src/usb_interface_pool.c +++ b/usb/ddk/host/src/usb_interface_pool.c @@ -1402,15 +1402,18 @@ int32_t UsbCloseCtlProcess(const UsbInterfaceHandle *interfaceHandle) } OsalMutexLock(&interfacePool->interfaceLock); - if (OsalAtomicRead(&interfacePool->ioRefCount) == 1) { + int32_t refCnt = OsalAtomicRead(&interfacePool->ioRefCount); + if (refCnt == 1) { ret = UsbIoRecvProcessStop(interfacePool); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s:%{public}d UsbIoStop failed, ret = %{public}d", __func__, __LINE__, ret); OsalMutexUnlock(&interfacePool->interfaceLock); return ret; } + } else { + HDF_LOGD("%{public}s:%{public}d UsbIoStop ref count = %{public}d", __func__, __LINE__, refCnt); } - + OsalMutexUnlock(&interfacePool->interfaceLock); return HDF_SUCCESS; } diff --git a/usb/ddk/host/src/usb_io_manage.c b/usb/ddk/host/src/usb_io_manage.c index 1d2031b958..96dc0932f3 100644 --- a/usb/ddk/host/src/usb_io_manage.c +++ b/usb/ddk/host/src/usb_io_manage.c @@ -85,6 +85,7 @@ static int32_t IoSendProcess(const void *interfacePoolArg) continue; } /* Submit success */ + OsalSemPost(&interfacePool->ioSem); break; } @@ -111,6 +112,7 @@ static int32_t IoAsyncReceiveProcess(const void *interfacePoolArg) HDF_LOGE("%{public}s:%{public}d RawRegisterSignal error", __func__, __LINE__); } + HDF_LOGD("%{public}s, enter recv thread", __func__); while (true) { if (!interfacePool->ioProcessTid) { interfacePool->ioProcessTid = RawGetTid(); @@ -128,12 +130,17 @@ static int32_t IoAsyncReceiveProcess(const void *interfacePoolArg) continue; } + int32_t ret = OsalSemWait(&interfacePool->ioSem, HDF_WAIT_FOREVER); + if (ret != HDF_SUCCESS) { + HDF_LOGE("sem wait failed: %{public}d", ret); + } + if (interfacePool->ioProcessStopStatus != USB_POOL_PROCESS_RUNNING || interfacePool->ioRecvProcessStopStatus != USB_POOL_PROCESS_RUNNING) { break; } - int32_t ret = RawHandleRequest(interfacePool->device->devHandle); + ret = RawHandleRequest(interfacePool->device->devHandle); if (ret < 0) { HDF_LOGE("%{public}s RawHandleRequest failed ret: %{public}d", __func__, ret); OsalMSleep(USB_IO_SLEEP_MS_TIME); @@ -255,6 +262,7 @@ HDF_STATUS UsbIoStart(struct UsbInterfacePool *interfacePool) OsalMutexLock(&interfacePool->ioStopLock); interfacePool->ioProcessStopStatus = USB_POOL_PROCESS_RUNNING; interfacePool->ioRecvProcessStopStatus = USB_POOL_PROCESS_RUNNING; + OsalSemInit(&interfacePool->ioSem, 0); OsalMutexUnlock(&interfacePool->ioStopLock); /* create IoSendProcess thread */ @@ -285,8 +293,7 @@ HDF_STATUS UsbIoStart(struct UsbInterfacePool *interfacePool) threadCfg.priority = OSAL_THREAD_PRI_DEFAULT; threadCfg.stackSize = USB_IO_RECEIVE_PROCESS_STACK_SIZE; - ret = OsalThreadCreate( - &interfacePool->ioAsyncReceiveProcess, (OsalThreadEntry)IoAsyncReceiveProcess, (void *)interfacePool); + ret = OsalThreadCreate(&interfacePool->ioAsyncReceiveProcess, (void *)IoAsyncReceiveProcess, (void *)interfacePool); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s:%{public}d OsalThreadCreate failed, ret=%{public}d ", __func__, __LINE__, ret); goto ERR_DESTROY_SEND; @@ -332,6 +339,7 @@ HDF_STATUS UsbIoStop(struct UsbInterfacePool *interfacePool) if ((interfacePool->ioProcessStopStatus != USB_POOL_PROCESS_STOPED)) { OsalMutexLock(&interfacePool->ioStopLock); interfacePool->ioProcessStopStatus = USB_POOL_PROCESS_STOP; + OsalSemPost(&interfacePool->ioSem); OsalSemPost(&interfacePool->submitRequestQueue.sem); OsalMutexUnlock(&interfacePool->ioStopLock); @@ -359,6 +367,8 @@ HDF_STATUS UsbIoStop(struct UsbInterfacePool *interfacePool) ret = OsalThreadDestroy(&interfacePool->ioAsyncReceiveProcess); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy failed, ret=%{public}d ", __func__, __LINE__, ret); + } else { + OsalSemDestroy(&interfacePool->ioSem); } return ret; } diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index f8e907af4e..bc7892fad4 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -44,7 +44,6 @@ constexpr uint16_t ENGLISH_US_LANGUAGE_ID = 0x409; constexpr uint32_t FUNCTION_VALUE_MAX_LEN = 32; constexpr uint8_t USB_PARAM_REQTYPE = 128; constexpr uint8_t USB_PARAM_STAND_REQTYPE = 0; -constexpr int32_t USB_TRANSFER_TIMEOUT = 1000; namespace OHOS { namespace HDI { namespace Usb { @@ -1099,13 +1098,6 @@ int32_t UsbImpl::CloseDevice(const UsbDev &dev) int32_t ret = 0; if (port->ctrDevHandle != nullptr) { RawUsbCloseCtlProcess(port->ctrDevHandle); - uint8_t activeConfig = 0; - uint16_t length = 1; - UsbControlParams controlParams; - MakeGetActiveUsbControlParams(&controlParams, &activeConfig, length, 0, 0); - UsbControlTransferEx(port, &controlParams, USB_TRANSFER_TIMEOUT); - HDF_LOGD("%{public}s:start closeInterface,busNum: %{public}d, devAddr: %{public}d ", - __func__, dev.busNum, dev.devAddr); ret = UsbCloseInterface(port->ctrDevHandle, true); if (ret != HDF_SUCCESS) { HDF_LOGE("%{public}s:usbCloseInterface ctrDevHandle failed.", __func__); -- Gitee From 805cc2168efc0e6aef0bba4a0871588f771030f7 Mon Sep 17 00:00:00 2001 From: yangkan Date: Tue, 27 Aug 2024 07:04:08 +0000 Subject: [PATCH 0375/1485] update display/composer/test/moduletest/hdi_device_test.cpp. Signed-off-by: yangkan --- display/composer/test/moduletest/hdi_device_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/display/composer/test/moduletest/hdi_device_test.cpp b/display/composer/test/moduletest/hdi_device_test.cpp index da0ce57c25..ed161bba21 100644 --- a/display/composer/test/moduletest/hdi_device_test.cpp +++ b/display/composer/test/moduletest/hdi_device_test.cpp @@ -385,7 +385,7 @@ void DeviceTest::TearDown() void DeviceLayerDisplay::TearDown() { HdiTestDevice::GetInstance().Clear(); -#if !defined(DISPLAY_COMMUNITY) +#ifndef DISPLAY_COMMUNITY HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer(); #endif } -- Gitee From 87e8e0fa1ac16388eca4378597c8d7650cd8cf22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=83=A1=E7=85=9C?= Date: Tue, 27 Aug 2024 15:44:02 +0800 Subject: [PATCH 0376/1485] =?UTF-8?q?iface=E6=8E=A5=E5=8F=A3=E6=9C=AA?= =?UTF-8?q?=E5=88=A0=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 胡煜 --- .../hdi_service/service_common/wpa_common_cmd_ext.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c index 6d2b8f74d2..61997c4258 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd_ext.c @@ -249,6 +249,7 @@ static int32_t StopWpaSupplicant(void) int32_t WpaInterfaceStop(struct IWpaInterface *self) { int32_t ret; + int32_t times = 0; (void)self; pthread_mutex_lock(GetInterfaceLock()); @@ -259,6 +260,15 @@ int32_t WpaInterfaceStop(struct IWpaInterface *self) pthread_mutex_unlock(GetInterfaceLock()); return HDF_FAILURE; } + while (g_tid != 0) { + HDF_LOGI("%{public}s: wpa_supplicant is not stop!", __func__); + usleep(WPA_SLEEP_TIME); + times++; + if (times > MAX_WPA_WAIT_TIMES) { + HDF_LOGE("%{public}s: wait supplicant stop time out!", __func__); + break; + } + } ReleaseWifiStaInterface(0); pthread_mutex_unlock(GetInterfaceLock()); HDF_LOGI("%{public}s: wpa_supplicant stop successfully!", __func__); -- Gitee From 66502dbe2f8f450442ded76edb745a3958fd574c Mon Sep 17 00:00:00 2001 From: shilong Date: Tue, 27 Aug 2024 12:48:46 +0000 Subject: [PATCH 0377/1485] =?UTF-8?q?=E5=88=A0=E9=99=A4FreeBSD=E7=BB=9D?= =?UTF-8?q?=E5=AF=B9=E8=B7=AF=E5=BE=84=E6=95=B4=E6=94=B9=EF=BC=8C=E4=BF=AE?= =?UTF-8?q?=E6=94=B9domainID?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: shilong --- input/udriver/BUILD.gn | 1 - input/utils/include/input_uhdf_log.h | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/input/udriver/BUILD.gn b/input/udriver/BUILD.gn index 595f23fa48..7aa444c5dd 100644 --- a/input/udriver/BUILD.gn +++ b/input/udriver/BUILD.gn @@ -26,7 +26,6 @@ if (drivers_peripheral_input_feature_udriver) { "$INPUT_ROOT_DIR/udriver/include", "$INPUT_ROOT_DIR/interfaces/include", "$INPUT_ROOT_DIR/utils/include", - "//third_party/FreeBSD/sys/dev/evdev", ] cflags = [ diff --git a/input/utils/include/input_uhdf_log.h b/input/utils/include/input_uhdf_log.h index 4b6c306ed9..55b833ddcf 100644 --- a/input/utils/include/input_uhdf_log.h +++ b/input/utils/include/input_uhdf_log.h @@ -21,6 +21,6 @@ #ifdef LOG_DOMAIN #undef LOG_DOMAIN #endif -#define LOG_DOMAIN 0xD002511 +#define LOG_DOMAIN 0xD002555 #endif //MOTION_UHDF_LOG_H \ No newline at end of file -- Gitee From 124ee342a6361b923a636021a75c415f96d0460f Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Tue, 27 Aug 2024 20:59:52 +0800 Subject: [PATCH 0378/1485] =?UTF-8?q?=E9=83=A8=E4=BB=B6=E7=8B=AC=E7=AB=8B?= =?UTF-8?q?=E7=BC=96=E8=AF=91=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- audio/bundle.json | 5 +- audio/hdi_service/supportlibs/BUILD.gn | 41 ++-- .../supportlibs/alsa_adapter/include/common.h | 35 +++ .../alsa_adapter/src/vendor_capture.c | 210 +++++++++++++++++ .../alsa_adapter/src/vendor_render.c | 223 ++++++++++++++++++ audio/test/benchmarktest/BUILD.gn | 7 +- .../BUILD.gn | 6 +- .../BUILD.gn | 6 +- .../BUILD.gn | 6 +- .../audiocardconfig_fuzzer/BUILD.gn | 11 +- .../pathselectconfig_fuzzer/BUILD.gn | 8 +- .../hdi_service/common/adapter/BUILD.gn | 6 +- .../hdi_service/common/capture/BUILD.gn | 6 +- .../hdi_service/common/manager/BUILD.gn | 6 +- .../hdi_service/common/render/BUILD.gn | 6 +- 15 files changed, 520 insertions(+), 62 deletions(-) create mode 100644 audio/supportlibs/alsa_adapter/include/common.h create mode 100644 audio/supportlibs/alsa_adapter/src/vendor_capture.c create mode 100644 audio/supportlibs/alsa_adapter/src/vendor_render.c diff --git a/audio/bundle.json b/audio/bundle.json index 0a2cab38d1..7c3824100d 100755 --- a/audio/bundle.json +++ b/audio/bundle.json @@ -40,9 +40,10 @@ "drivers_interface_audio", "bounds_checking_function", "hitrace", - "hicollie" + "hicollie", + "alsa-lib" ], - "third_party": [ "alsa-lib" ] + "third_party": [] }, "build": { "sub_component": [ diff --git a/audio/hdi_service/supportlibs/BUILD.gn b/audio/hdi_service/supportlibs/BUILD.gn index 080713fca1..c505c9fa95 100644 --- a/audio/hdi_service/supportlibs/BUILD.gn +++ b/audio/hdi_service/supportlibs/BUILD.gn @@ -77,11 +77,10 @@ if (defined(ohos_lite)) { "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_capture.c", "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_snd_capture.c", "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", - "//third_party/cJSON/cJSON.c", ] if (defined(is_emulator) && is_emulator) { sources += [ - "//device/hmos_emulator/hardware/audio/audio_alsa/vendor_capture.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_capture.c", ] } else { sources += [ "//device/board/${product_company}/${device_name}/audio_alsa/vendor_capture.c" ] @@ -100,18 +99,11 @@ if (defined(ohos_lite)) { public_deps = [] if (drivers_peripheral_audio_feature_alsa_lib) { - include_dirs += [ - "//third_party/cJSON", - "//third_party/alsa-lib/include", - "$hdf_audio_path/supportlibs/alsa_adapter/include", - ] - if (defined(is_emulator) && is_emulator) { - include_dirs += [ "//device/hmos_emulator/hardware/audio/audio_alsa" ] - } else { + include_dirs += [ "$hdf_audio_path/supportlibs/alsa_adapter/include" ] + if (!defined(is_emulator) || !is_emulator) { include_dirs += [ "//device/board/${product_company}/${device_name}/audio_alsa" ] } - public_deps += [ "//third_party/alsa-lib:libasound" ] } else { include_dirs += [ "$hdf_audio_path/supportlibs/adm_adapter/include" ] } @@ -141,6 +133,12 @@ if (defined(ohos_lite)) { external_deps = [ "hilog:libhilog" ] } external_deps += [ "bounds_checking_function:libsec_shared" ] + if (drivers_peripheral_audio_feature_alsa_lib) { + external_deps += [ + "alsa-lib:libasound", + "cJSON:cjson", + ] + } install_images = [ chipset_base_dir ] subsystem_name = "hdf" @@ -154,12 +152,10 @@ if (defined(ohos_lite)) { "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_lib_render.c", "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_snd_render.c", "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", - "//device/board/${product_company}/${device_name}/audio_alsa/vendor_render.c", - "//third_party/cJSON/cJSON.c", ] if (defined(is_emulator) && is_emulator) { sources += [ - "//device/hmos_emulator/hardware/audio/audio_alsa/vendor_render.c", + "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_render.c", ] } else { sources += [ "//device/board/${product_company}/${device_name}/audio_alsa/vendor_render.c" ] @@ -179,18 +175,11 @@ if (defined(ohos_lite)) { public_deps = [] if (drivers_peripheral_audio_feature_alsa_lib) { - include_dirs += [ - "//third_party/cJSON", - "//third_party/alsa-lib/include", - "$hdf_audio_path/supportlibs/alsa_adapter/include", - ] - if (defined(is_emulator) && is_emulator) { - include_dirs += [ "//device/hmos_emulator/hardware/audio/audio_alsa" ] - } else { + include_dirs += [ "$hdf_audio_path/supportlibs/alsa_adapter/include" ] + if (!defined(is_emulator) || !is_emulator) { include_dirs += [ "//device/board/${product_company}/${device_name}/audio_alsa" ] } - public_deps += [ "//third_party/alsa-lib:libasound" ] } else { include_dirs += [ "$hdf_audio_path/supportlibs/adm_adapter/include" ] } @@ -220,6 +209,12 @@ if (defined(ohos_lite)) { external_deps = [ "hilog:libhilog" ] } external_deps += [ "bounds_checking_function:libsec_shared" ] + if (drivers_peripheral_audio_feature_alsa_lib) { + external_deps += [ + "alsa-lib:libasound", + "cJSON:cjson", + ] + } install_images = [ chipset_base_dir ] subsystem_name = "hdf" diff --git a/audio/supportlibs/alsa_adapter/include/common.h b/audio/supportlibs/alsa_adapter/include/common.h new file mode 100644 index 0000000000..29bdc01e92 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/include/common.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALSA_SND_COMMON_H +#define ALSA_SND_COMMON_H + +/* Master Playback Volume */ +#define SND_NUMID_DACL_PLAYBACK_VOL 1 +#define SND_ELEM_DACL_PLAYBACK_VOL "Master Playback Volume" + +/* Master Playback Volume */ +#define SND_NUMID_DACR_PLAYBACK_VOL 1 +#define SND_ELEM_DACR_PLAYBACK_VOL "Master Playback Volume" + +/* Master Capture Volume */ +#define SND_NUMID_DACL_CAPTURE_VOL 1 +#define SND_ELEM_DACL_CAPTURE_VOL "Master Capture Volume" + +/* Master Capture Volume */ +#define SND_NUMID_DACR_CAPTURE_VOL 1 +#define SND_ELEM_DACR_CAPTURE_VOL "Master Capture Volume" + +#endif /* ALSA_SND_COMMON_H */ diff --git a/audio/supportlibs/alsa_adapter/src/vendor_capture.c b/audio/supportlibs/alsa_adapter/src/vendor_capture.c new file mode 100644 index 0000000000..2bce2e2a92 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/src/vendor_capture.c @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "alsa_snd_capture.h" +#include "common.h" + +#define HDF_LOG_TAG HDF_AUDIO_HAL_CAPTURE + +typedef struct _CAPTURE_DATA_ { + struct AlsaMixerCtlElement ctrlLeftVolume; + struct AlsaMixerCtlElement ctrlRightVolume; + long tempVolume; +}CaptureData; + +static int32_t CaptureInitImpl(struct AlsaCapture* captureIns) +{ + if (captureIns->priData != NULL) { + return HDF_SUCCESS; + } + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + + CaptureData *priData = (CaptureData *)OsalMemCalloc(sizeof(CaptureData)); + if (priData == NULL) { + AUDIO_FUNC_LOGE("Failed to allocate memory!"); + return HDF_FAILURE; + } + + SndElementItemInit(&priData->ctrlLeftVolume); + SndElementItemInit(&priData->ctrlRightVolume); + priData->ctrlLeftVolume.numid = SND_NUMID_DACL_CAPTURE_VOL; + priData->ctrlLeftVolume.name = SND_ELEM_DACL_CAPTURE_VOL; + priData->ctrlRightVolume.numid = SND_NUMID_DACR_CAPTURE_VOL; + priData->ctrlRightVolume.name = SND_ELEM_DACR_CAPTURE_VOL; + CaptureSetPriData(captureIns, (CapturePriData)priData); + + return HDF_SUCCESS; +} + +static int32_t CaptureSelectSceneImpl(struct AlsaCapture *captureIns, enum AudioPortPin descPins, + const struct PathDeviceInfo *deviceInfo) +{ + captureIns->descPins = descPins; + return HDF_SUCCESS; +} + +static int32_t CaptureGetVolThresholdImpl(struct AlsaCapture *captureIns, long *volMin, long *volMax) +{ + int32_t ret; + long _volMin = 0; + long _volMax = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CaptureData *priData = CaptureGetPriData(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &_volMin, &_volMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SndElementReadRange fail!"); + return HDF_FAILURE; + } + *volMin = _volMin; + *volMax = _volMax; + + return HDF_SUCCESS; +} + +static int32_t CaptureGetVolumeImpl(struct AlsaCapture *captureIns, long *volume) +{ + int32_t ret; + long volLeft = 0; + long volRight = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CaptureData *priData = CaptureGetPriData(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = SndElementReadInt(cardIns, &priData->ctrlLeftVolume, &volLeft); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Read left volume fail!"); + return HDF_FAILURE; + } + ret = SndElementReadInt(cardIns, &priData->ctrlRightVolume, &volRight); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Read right volume fail!"); + return HDF_FAILURE; + } + *volume = (volLeft + volRight) >> 1; + + return HDF_SUCCESS; +} + +static int32_t CaptureSetVolumeImpl(struct AlsaCapture *captureIns, long volume) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + CaptureData *priData = CaptureGetPriData(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + ret = SndElementWriteInt(cardIns, &priData->ctrlLeftVolume, volume); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Write left volume fail!"); + return HDF_FAILURE; + } + ret = SndElementWriteInt(cardIns, &priData->ctrlRightVolume, volume); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Write right volume fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t CaptureSetMuteImpl(struct AlsaCapture *captureIns, bool muteFlag) +{ + int32_t ret; + long vol, setVol; + CaptureData *priData = CaptureGetPriData(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(captureIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + ret = captureIns->GetVolume(captureIns, &vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("GetVolume failed!"); + return HDF_FAILURE; + } + + if (muteFlag) { + priData->tempVolume = vol; + setVol = 0; + } else { + setVol = priData->tempVolume; + } + captureIns->SetVolume(captureIns, setVol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetVolume failed!"); + return HDF_FAILURE; + } + captureIns->muteState = muteFlag; + return HDF_SUCCESS; +} + +static int32_t CaptureStartImpl(struct AlsaCapture *captureIns) +{ + return HDF_SUCCESS; +} + +static int32_t CaptureStopImpl(struct AlsaCapture *captureIns) +{ + snd_pcm_drop(captureIns->soundCard.pcmHandle); + return HDF_SUCCESS; +} + +static int32_t CaptureGetGainThresholdImpl(struct AlsaCapture *captureIns, float *gainMin, float *gainMax) +{ + AUDIO_FUNC_LOGE("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static int32_t CaptureGetGainImpl(struct AlsaCapture *captureIns, float *volume) +{ + AUDIO_FUNC_LOGE("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static int32_t CaptureSetGainImpl(struct AlsaCapture *captureIns, float volume) +{ + AUDIO_FUNC_LOGE("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static bool CaptureGetMuteImpl(struct AlsaCapture *captureIns) +{ + return captureIns->muteState; +} + +int32_t CaptureOverrideFunc(struct AlsaCapture *captureIns) +{ + if (captureIns == NULL) { + return HDF_FAILURE; + } + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; + + if (cardIns->cardType == SND_CARD_PRIMARY) { + captureIns->Init = CaptureInitImpl; + captureIns->SelectScene = CaptureSelectSceneImpl; + captureIns->Start = CaptureStartImpl; + captureIns->Stop = CaptureStopImpl; + captureIns->GetVolThreshold = CaptureGetVolThresholdImpl; + captureIns->GetVolume = CaptureGetVolumeImpl; + captureIns->SetVolume = CaptureSetVolumeImpl; + captureIns->GetGainThreshold = CaptureGetGainThresholdImpl; + captureIns->GetGain = CaptureGetGainImpl; + captureIns->SetGain = CaptureSetGainImpl; + captureIns->GetMute = CaptureGetMuteImpl; + captureIns->SetMute = CaptureSetMuteImpl; + } + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/audio/supportlibs/alsa_adapter/src/vendor_render.c b/audio/supportlibs/alsa_adapter/src/vendor_render.c new file mode 100644 index 0000000000..364837f5e4 --- /dev/null +++ b/audio/supportlibs/alsa_adapter/src/vendor_render.c @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "alsa_snd_render.h" +#include "common.h" + +#define HDF_LOG_TAG HDF_AUDIO_HAL_RENDER + +typedef struct _RENDER_DATA_ { + struct AlsaMixerCtlElement ctrlLeftVolume; + struct AlsaMixerCtlElement ctrlRightVolume; + long tempVolume; +}RenderData; + +static int32_t RenderInitImpl(struct AlsaRender *renderIns) +{ + if (renderIns->priData != NULL) { + return HDF_SUCCESS; + } + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + + RenderData *priData = (RenderData *)OsalMemCalloc(sizeof(RenderData)); + if (priData == NULL) { + AUDIO_FUNC_LOGE("Failed to allocate memory!"); + return HDF_FAILURE; + } + + SndElementItemInit(&priData->ctrlLeftVolume); + SndElementItemInit(&priData->ctrlRightVolume); + priData->ctrlLeftVolume.numid = SND_NUMID_DACL_PLAYBACK_VOL; + priData->ctrlLeftVolume.name = SND_ELEM_DACL_PLAYBACK_VOL; + priData->ctrlRightVolume.numid = SND_NUMID_DACR_PLAYBACK_VOL; + priData->ctrlRightVolume.name = SND_ELEM_DACR_PLAYBACK_VOL; + RenderSetPriData(renderIns, (RenderPriData)priData); + + return HDF_SUCCESS; +} + +static int32_t RenderSelectSceneImpl(struct AlsaRender *renderIns, enum AudioPortPin descPins, + const struct PathDeviceInfo *deviceInfo) +{ + renderIns->descPins = descPins; + return HDF_SUCCESS; +} + +static int32_t RenderGetVolThresholdImpl(struct AlsaRender *renderIns, long *volMin, long *volMax) +{ + int32_t ret; + long _volMin = 0; + long _volMax = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + RenderData *priData = RenderGetPriData(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &_volMin, &_volMax); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SndElementReadRange fail!"); + return HDF_FAILURE; + } + *volMin = _volMin; + *volMax = _volMax; + + return HDF_SUCCESS; +} + +static int32_t RenderGetVolumeImpl(struct AlsaRender *renderIns, long *volume) +{ + int32_t ret; + long volLeft = 0; + long volRight = 0; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + RenderData *priData = RenderGetPriData(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = SndElementReadInt(cardIns, &priData->ctrlLeftVolume, &volLeft); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Read left volume fail!"); + return HDF_FAILURE; + } + ret = SndElementReadInt(cardIns, &priData->ctrlRightVolume, &volRight); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Read right volume fail!"); + return HDF_FAILURE; + } + *volume = (volLeft + volRight) >> 1; + + return HDF_SUCCESS; +} + +static int32_t RenderSetVolumeImpl(struct AlsaRender *renderIns, long volume) +{ + int32_t ret; + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + RenderData *priData = RenderGetPriData(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = SndElementWriteInt(cardIns, &priData->ctrlLeftVolume, volume); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Write left volume fail!"); + return HDF_FAILURE; + } + ret = SndElementWriteInt(cardIns, &priData->ctrlRightVolume, volume); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("Write right volume fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static bool RenderGetMuteImpl(struct AlsaRender *renderIns) +{ + return renderIns->muteState; +} + +static int32_t RenderSetMuteImpl(struct AlsaRender *renderIns, bool muteFlag) +{ + int32_t ret; + long vol, setVol; + RenderData *priData = RenderGetPriData(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(renderIns); + CHECK_NULL_PTR_RETURN_DEFAULT(priData); + + ret = renderIns->GetVolume(renderIns, &vol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("GetVolume failed!"); + return HDF_FAILURE; + } + + if (muteFlag) { + priData->tempVolume = vol; + setVol = 0; + } else { + setVol = priData->tempVolume; + } + + renderIns->SetVolume(renderIns, setVol); + if (ret != HDF_SUCCESS) { + AUDIO_FUNC_LOGE("SetVolume failed!"); + return HDF_FAILURE; + } + renderIns->muteState = muteFlag; + + return HDF_SUCCESS; +} + +static int32_t RenderStartImpl(struct AlsaRender *renderIns) +{ + return HDF_SUCCESS; +} + +static int32_t RenderStopImpl(struct AlsaRender *renderIns) +{ + snd_pcm_drain(renderIns->soundCard.pcmHandle); + return HDF_SUCCESS; +} + +static int32_t RenderGetGainThresholdImpl(struct AlsaRender *renderIns, float *gainMin, float *gainMax) +{ + AUDIO_FUNC_LOGI("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static int32_t RenderGetGainImpl(struct AlsaRender *renderIns, float *volume) +{ + AUDIO_FUNC_LOGI("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static int32_t RenderSetGainImpl(struct AlsaRender *renderIns, float volume) +{ + AUDIO_FUNC_LOGI("emulator not support gain operation"); + return HDF_SUCCESS; +} + +static int32_t RenderGetChannelModeImpl(struct AlsaRender *renderIns, enum AudioChannelMode *mode) +{ + return HDF_SUCCESS; +} + +static int32_t RenderSetChannelModeImpl(struct AlsaRender *renderIns, enum AudioChannelMode mode) +{ + return HDF_SUCCESS; +} + +int32_t RenderOverrideFunc(struct AlsaRender *renderIns) +{ + struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; + + if (cardIns->cardType == SND_CARD_PRIMARY) { + renderIns->Init = RenderInitImpl; + renderIns->SelectScene = RenderSelectSceneImpl; + renderIns->Start = RenderStartImpl; + renderIns->Stop = RenderStopImpl; + renderIns->GetVolThreshold = RenderGetVolThresholdImpl; + renderIns->GetVolume = RenderGetVolumeImpl; + renderIns->SetVolume = RenderSetVolumeImpl; + renderIns->GetGainThreshold = RenderGetGainThresholdImpl; + renderIns->GetGain = RenderGetGainImpl; + renderIns->SetGain = RenderSetGainImpl; + renderIns->GetMute = RenderGetMuteImpl; + renderIns->SetMute = RenderSetMuteImpl; + renderIns->GetChannelMode = RenderGetChannelModeImpl; + renderIns->SetChannelMode = RenderSetChannelModeImpl; + } + + return HDF_SUCCESS; +} diff --git a/audio/test/benchmarktest/BUILD.gn b/audio/test/benchmarktest/BUILD.gn index 690a2f7c4e..4c1a77b882 100644 --- a/audio/test/benchmarktest/BUILD.gn +++ b/audio/test/benchmarktest/BUILD.gn @@ -47,11 +47,6 @@ ohos_benchmarktest("hdf_audio_benchmark_test") { "-fno-strict-aliasing", ] - deps = [ - "//third_party/benchmark", - "//third_party/googletest:gtest_main", - ] - if (is_standard_system) { external_deps = [ "drivers_interface_audio:libaudio_proxy_4.0", @@ -68,7 +63,9 @@ ohos_benchmarktest("hdf_audio_benchmark_test") { external_deps = [ "hilog:libhilog" ] } external_deps += [ + "benchmark:benchmark", "bounds_checking_function:libsec_shared", + "googletest:gtest_main", "ipc:ipc_single", ] } diff --git a/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercapturecmdid_fuzzer/BUILD.gn b/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercapturecmdid_fuzzer/BUILD.gn index b604bce602..dfd8115ca5 100644 --- a/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercapturecmdid_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercapturecmdid_fuzzer/BUILD.gn @@ -46,7 +46,6 @@ ohos_fuzztest("AudioAdmDispatcherCaptureCmdidFuzzTest") { "$hdf_fuzztest_path/common/include", "$hdf_test_path/systemtest/common/hdi_common/include", "$hdf_test_path/systemtest/common/adm_common/include", - "//third_party/googletest/googletest/include", ] external_deps = [ "hdf_core:libhdf_utils" ] if (defined(ohos_lite)) { @@ -57,7 +56,10 @@ ohos_fuzztest("AudioAdmDispatcherCaptureCmdidFuzzTest") { if (enable_c_utils) { external_deps += [ "c_utils:utils" ] } - external_deps += [ "bounds_checking_function:libsec_shared" ] + external_deps += [ + "bounds_checking_function:libsec_shared", + "googletest:gtest", + ] defines = [] if (enable_audio_adm_passthrough) { defines += [ "AUDIO_ADM_SO" ] diff --git a/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercontrolcmdid_fuzzer/BUILD.gn b/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercontrolcmdid_fuzzer/BUILD.gn index d6e309b35d..22051db0cb 100644 --- a/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercontrolcmdid_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/adm_fuzzer/audioadmdispatchercontrolcmdid_fuzzer/BUILD.gn @@ -46,7 +46,6 @@ ohos_fuzztest("AudioAdmDispatcherControlCmdidFuzzTest") { "$hdf_fuzztest_path/common/include", "$hdf_test_path/systemtest/common/hdi_common/include", "$hdf_test_path/systemtest/common/adm_common/include", - "//third_party/googletest/googletest/include", ] external_deps = [ "hdf_core:libhdf_utils" ] if (defined(ohos_lite)) { @@ -57,7 +56,10 @@ ohos_fuzztest("AudioAdmDispatcherControlCmdidFuzzTest") { if (enable_c_utils) { external_deps += [ "c_utils:utils" ] } - external_deps += [ "bounds_checking_function:libsec_shared" ] + external_deps += [ + "bounds_checking_function:libsec_shared", + "googletest:gtest", + ] defines = [] if (enable_audio_adm_passthrough) { defines += [ "AUDIO_ADM_SO" ] diff --git a/audio/test/fuzztest/adm_fuzzer/audioadmdispatcherrendercmdid_fuzzer/BUILD.gn b/audio/test/fuzztest/adm_fuzzer/audioadmdispatcherrendercmdid_fuzzer/BUILD.gn index 88a87735cf..fd80a38e78 100644 --- a/audio/test/fuzztest/adm_fuzzer/audioadmdispatcherrendercmdid_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/adm_fuzzer/audioadmdispatcherrendercmdid_fuzzer/BUILD.gn @@ -46,7 +46,6 @@ ohos_fuzztest("AudioAdmDispatcherRenderCmdidFuzzTest") { "$hdf_fuzztest_path/common/include", "$hdf_test_path/systemtest/common/hdi_common/include", "$hdf_test_path/systemtest/common/adm_common/include", - "//third_party/googletest/googletest/include", ] external_deps = [ "hdf_core:libhdf_utils" ] if (defined(ohos_lite)) { @@ -57,7 +56,10 @@ ohos_fuzztest("AudioAdmDispatcherRenderCmdidFuzzTest") { if (enable_c_utils) { external_deps += [ "c_utils:utils" ] } - external_deps += [ "bounds_checking_function:libsec_shared" ] + external_deps += [ + "bounds_checking_function:libsec_shared", + "googletest:gtest", + ] defines = [] if (enable_audio_adm_passthrough) { defines += [ "AUDIO_ADM_SO" ] diff --git a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn index b3e1204e2f..f3eba3a177 100644 --- a/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/audio_config_fuzzer/audiocardconfig_fuzzer/BUILD.gn @@ -33,11 +33,8 @@ ohos_fuzztest("AudioCardConfigFuzzTest") { "$hdf_audio_path/supportlibs/alsa_adapter/include", "$hdf_audio_path/supportlibs/interfaces/include", "$hdf_audio_path/interfaces/include", - "//third_party/cJSON/", ] - deps = [ "//third_party/cJSON:cjson" ] - external_deps = [ "hdf_core:libhdf_utils" ] if (defined(ohos_lite)) { external_deps += [ "hilog_lite:hilog_share" ] @@ -47,7 +44,9 @@ ohos_fuzztest("AudioCardConfigFuzzTest") { if (enable_c_utils) { external_deps += [ "c_utils:utils" ] } - external_deps += [ "bounds_checking_function:libsec_shared" ] - - include_dirs += [ "//third_party/alsa-lib/include" ] + external_deps += [ + "alsa-lib:libasound", + "bounds_checking_function:libsec_shared", + "cJSON:cjson", + ] } diff --git a/audio/test/fuzztest/audio_config_fuzzer/pathselectconfig_fuzzer/BUILD.gn b/audio/test/fuzztest/audio_config_fuzzer/pathselectconfig_fuzzer/BUILD.gn index 3fd6042e4f..5d931f483b 100644 --- a/audio/test/fuzztest/audio_config_fuzzer/pathselectconfig_fuzzer/BUILD.gn +++ b/audio/test/fuzztest/audio_config_fuzzer/pathselectconfig_fuzzer/BUILD.gn @@ -31,12 +31,12 @@ ohos_fuzztest("PathSelectConfigFuzzTest") { "$hdf_audio_path/hal/pathselect/include", "$hdf_audio_path/hal/hdi_passthrough/include", "$hdf_audio_path/interfaces/include", - "//third_party/cJSON/", ] - deps = [ "//third_party/cJSON:cjson" ] - - external_deps = [ "hdf_core:libhdf_utils" ] + external_deps = [ + "cJSON:cjson", + "hdf_core:libhdf_utils", + ] if (defined(ohos_lite)) { external_deps += [ "hilog_lite:hilog_share" ] } else { diff --git a/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn b/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn index 943217192e..408466c2a2 100644 --- a/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/adapter/BUILD.gn @@ -26,6 +26,8 @@ ohos_systemtest("hdf_audio_idlhdi_adapter_test") { external_deps = [ "bounds_checking_function:libsec_shared", "drivers_interface_audio:libaudio_proxy_4.0", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", ] if (defined(ohos_lite)) { @@ -38,10 +40,6 @@ ohos_systemtest("hdf_audio_idlhdi_adapter_test") { } include_dirs = [ "./../../../common/hdi_service_common/include" ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] defines = [] if (drivers_peripheral_audio_feature_community) { defines += [ "AUDIO_SAMPLE_LOW_BITWIDTH" ] diff --git a/audio/test/systemtest/hdi_service/common/capture/BUILD.gn b/audio/test/systemtest/hdi_service/common/capture/BUILD.gn index c3a18b7543..6bd269616b 100644 --- a/audio/test/systemtest/hdi_service/common/capture/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/capture/BUILD.gn @@ -35,14 +35,12 @@ if (!defined(ohos_lite)) { external_deps = [ "bounds_checking_function:libsec_shared", "drivers_interface_audio:libaudio_proxy_4.0", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] defines = [] if (drivers_peripheral_audio_feature_community) { defines += [ "AUDIO_SAMPLE_LOW_BITWIDTH" ] diff --git a/audio/test/systemtest/hdi_service/common/manager/BUILD.gn b/audio/test/systemtest/hdi_service/common/manager/BUILD.gn index 5ae6cf534a..25d8e19f23 100644 --- a/audio/test/systemtest/hdi_service/common/manager/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/manager/BUILD.gn @@ -31,14 +31,12 @@ if (!defined(ohos_lite)) { external_deps = [ "bounds_checking_function:libsec_shared", "drivers_interface_audio:libaudio_proxy_4.0", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", "hilog:libhilog", ] - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] defines = [] if (drivers_peripheral_audio_feature_community) { defines += [ "AUDIO_SAMPLE_LOW_BITWIDTH" ] diff --git a/audio/test/systemtest/hdi_service/common/render/BUILD.gn b/audio/test/systemtest/hdi_service/common/render/BUILD.gn index ab44e31b10..2f1279e2f7 100644 --- a/audio/test/systemtest/hdi_service/common/render/BUILD.gn +++ b/audio/test/systemtest/hdi_service/common/render/BUILD.gn @@ -34,6 +34,8 @@ ohos_systemtest("hdf_audio_idlhdi_render_test") { external_deps = [ "bounds_checking_function:libsec_shared", "drivers_interface_audio:libaudio_proxy_4.0", + "googletest:gmock_main", + "googletest:gtest_main", "hdf_core:libhdf_utils", ] if (defined(ohos_lite)) { @@ -42,10 +44,6 @@ ohos_systemtest("hdf_audio_idlhdi_render_test") { external_deps += [ "hilog:libhilog" ] } - deps = [ - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] defines = [] if (drivers_peripheral_audio_feature_community) { defines += [ "AUDIO_SAMPLE_LOW_BITWIDTH" ] -- Gitee From 1aa1c5355407e2282e22f90fa9aa99d023ec0799 Mon Sep 17 00:00:00 2001 From: xionglei Date: Tue, 27 Aug 2024 13:07:22 +0000 Subject: [PATCH 0379/1485] update wlan/client/src/netlink/netlink_cmd_adapter.c. Signed-off-by: xionglei --- wlan/client/src/netlink/netlink_cmd_adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/client/src/netlink/netlink_cmd_adapter.c b/wlan/client/src/netlink/netlink_cmd_adapter.c index 29b3f9884c..aea5c4ba4d 100644 --- a/wlan/client/src/netlink/netlink_cmd_adapter.c +++ b/wlan/client/src/netlink/netlink_cmd_adapter.c @@ -122,7 +122,7 @@ static inline uint32_t BIT(uint8_t x) #endif #define SUBCHIP_WIFI_PROP "ohos.boot.odm.conn.schiptype" -#define SUPPORT_COEXCHIP "bisheng" +#define SUPPORT_COEXCHIP "" #define SUBCHIP_WIFI_PROP_LEN 10 #define SUPPORT_COEXCHIP_LEN 7 -- Gitee From 25a9745e47e6dba22ec1d8fd8e247cb24a17a8ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Wed, 28 Aug 2024 02:52:58 +0000 Subject: [PATCH 0380/1485] update audio/supportlibs/alsa_adapter/src/vendor_capture.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/supportlibs/alsa_adapter/src/vendor_capture.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/src/vendor_capture.c b/audio/supportlibs/alsa_adapter/src/vendor_capture.c index 2bce2e2a92..413e322f61 100644 --- a/audio/supportlibs/alsa_adapter/src/vendor_capture.c +++ b/audio/supportlibs/alsa_adapter/src/vendor_capture.c @@ -58,20 +58,20 @@ static int32_t CaptureSelectSceneImpl(struct AlsaCapture *captureIns, enum Audio static int32_t CaptureGetVolThresholdImpl(struct AlsaCapture *captureIns, long *volMin, long *volMax) { int32_t ret; - long _volMin = 0; - long _volMax = 0; + long volMin = 0; + long volMax = 0; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)captureIns; CaptureData *priData = CaptureGetPriData(captureIns); CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(priData); - ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &_volMin, &_volMax); + ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &volMin, &volMax); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("SndElementReadRange fail!"); return HDF_FAILURE; } - *volMin = _volMin; - *volMax = _volMax; + *volMin = volMin; + *volMax = volMax; return HDF_SUCCESS; } -- Gitee From 38108a84286fab7495a251c22f57aabeda6210d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E5=AD=A6=E6=B5=B7?= Date: Wed, 28 Aug 2024 02:53:29 +0000 Subject: [PATCH 0381/1485] update audio/supportlibs/alsa_adapter/src/vendor_render.c. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 许学海 --- audio/supportlibs/alsa_adapter/src/vendor_render.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/audio/supportlibs/alsa_adapter/src/vendor_render.c b/audio/supportlibs/alsa_adapter/src/vendor_render.c index 364837f5e4..7221bd29c3 100644 --- a/audio/supportlibs/alsa_adapter/src/vendor_render.c +++ b/audio/supportlibs/alsa_adapter/src/vendor_render.c @@ -58,20 +58,20 @@ static int32_t RenderSelectSceneImpl(struct AlsaRender *renderIns, enum AudioPor static int32_t RenderGetVolThresholdImpl(struct AlsaRender *renderIns, long *volMin, long *volMax) { int32_t ret; - long _volMin = 0; - long _volMax = 0; + long volMin = 0; + long volMax = 0; struct AlsaSoundCard *cardIns = (struct AlsaSoundCard *)renderIns; RenderData *priData = RenderGetPriData(renderIns); CHECK_NULL_PTR_RETURN_DEFAULT(cardIns); CHECK_NULL_PTR_RETURN_DEFAULT(priData); - ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &_volMin, &_volMax); + ret = SndElementReadRange(cardIns, &priData->ctrlLeftVolume, &volMin, &volMax); if (ret != HDF_SUCCESS) { AUDIO_FUNC_LOGE("SndElementReadRange fail!"); return HDF_FAILURE; } - *volMin = _volMin; - *volMax = _volMax; + *volMin = volMin; + *volMax = volMax; return HDF_SUCCESS; } -- Gitee From c7761d80f8fbac502e7574754012e664c10b7fd5 Mon Sep 17 00:00:00 2001 From: xuxuehai Date: Wed, 28 Aug 2024 11:04:14 +0800 Subject: [PATCH 0382/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9gn=E6=96=87?= =?UTF-8?q?=E4=BB=B6=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuxuehai --- audio/hdi_service/supportlibs/BUILD.gn | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/audio/hdi_service/supportlibs/BUILD.gn b/audio/hdi_service/supportlibs/BUILD.gn index c505c9fa95..43913338d1 100644 --- a/audio/hdi_service/supportlibs/BUILD.gn +++ b/audio/hdi_service/supportlibs/BUILD.gn @@ -79,9 +79,8 @@ if (defined(ohos_lite)) { "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", ] if (defined(is_emulator) && is_emulator) { - sources += [ - "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_capture.c", - ] + sources += + [ "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_capture.c" ] } else { sources += [ "//device/board/${product_company}/${device_name}/audio_alsa/vendor_capture.c" ] } @@ -154,9 +153,8 @@ if (defined(ohos_lite)) { "$hdf_audio_path/supportlibs/alsa_adapter/src/alsa_soundcard.c", ] if (defined(is_emulator) && is_emulator) { - sources += [ - "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_render.c", - ] + sources += + [ "$hdf_audio_path/supportlibs/alsa_adapter/src/vendor_render.c" ] } else { sources += [ "//device/board/${product_company}/${device_name}/audio_alsa/vendor_render.c" ] } -- Gitee From ba5e002822072808ae4dc7f24a4bf37bf8337df0 Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Wed, 28 Aug 2024 20:42:25 +0800 Subject: [PATCH 0383/1485] add test Signed-off-by: huangshengqing --- .../test/hdi/v1_3/include/hdi_common_v1_3.h | 7 + .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 209 ++++++++++++++++++ camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp | 24 ++ 3 files changed, 240 insertions(+) diff --git a/camera/test/hdi/v1_3/include/hdi_common_v1_3.h b/camera/test/hdi/v1_3/include/hdi_common_v1_3.h index 4f4cc87531..b63c480353 100644 --- a/camera/test/hdi/v1_3/include/hdi_common_v1_3.h +++ b/camera/test/hdi/v1_3/include/hdi_common_v1_3.h @@ -86,6 +86,7 @@ public: void DefaultPreview(std::shared_ptr &infos); void DefaultCapture(std::shared_ptr &infos); void DefaultSketch(std::shared_ptr &infos); + void DefaultMeta(std::shared_ptr &infos); void DefaultInfosPreview(std::shared_ptr &infos); void DefaultInfosPreviewV1_2(std::shared_ptr &infos); void DefaultInfosCapture(std::shared_ptr &infos); @@ -93,6 +94,7 @@ public: void DefaultInfosAnalyze(std::shared_ptr &infos); void DefaultInfosVideo(std::shared_ptr &infos); void DefaultInfosSketch(std::shared_ptr &infos); + void DefaultInfosMeta(std::shared_ptr &infos); void StartProfessionalStream(std::vector intents, uint8_t professionalMode); void StartStream(std::vector intents, OHOS::HDI::Camera::V1_3::OperationMode mode = OHOS::HDI::Camera::V1_3::NORMAL); @@ -120,6 +122,7 @@ public: std::shared_ptr streamInfoPre = nullptr; std::shared_ptr streamInfoVideo = nullptr; std::shared_ptr streamInfoSketch = nullptr; + std::shared_ptr streamInfoMeta = nullptr; std::shared_ptr captureInfo = nullptr; int previewFormat = PIXEL_FMT_YCRCB_420_SP; int videoFormat = PIXEL_FMT_YCRCB_420_SP; @@ -128,12 +131,16 @@ public: int streamIdPreview = 100; int streamIdCapture = 101; int streamIdSketch = 105; + int streamIdMeta = 106; int captureWidth = 1280; int captureHeight = 960; int sketchWidth = 640; + int metaWidth = 640; int sketchHeight = 480; + int metaHeight = 480; int captureIdPreview = 2000; int captureIdSketch = 2050; + int captureIdMeta = 2060; int previewWidth = 1920; int previewHeight = 1080; int captureIdCapture = 2010; diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index c4f0a50681..799abe973d 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -1985,4 +1985,213 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_048, TestSize.Level1) cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } } +} + +/** + * @tc.name: Camera_Device_Hdi_V1_3_049 + * @tc.desc: OHOS_ABILITY_LCD_FLASH OHOS_CONTROL_LCD_FLASH_DETECTION OHOS_STATUS_LCD_FLASH_STATUS OHOS_CONTROL_LCD_FLASH + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1) +{ + // 查询是否支持环形补光 + ASSERT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + ASSERT_NE(data, nullptr); + camera_metadata_item_t entry; + cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LCD_FLASH, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (*entry.data.i32 == 1) { + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); + // 开启预览流 + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + // 使能环形补光 + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t lcdFlashDetection = 1; + meta->addEntry(OHOS_CONTROL_LCD_FLASH_DETECTION, &lcdFlashDetection, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + sleep(3); + if (cameraTest->deviceCallback->resultMeta == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult not be invoked."); + return; + } + // 返回结果是否需要环形补光 + common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get(); + if (data == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult be invoked but data was nullptr."); + return; + } + camera_metadata_item_t entry; + cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_LCD_FLASH_STATUS, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (entry.data.i32[0] == 1) { + // 使能环形补光 + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t lcdFlash = 1; + meta->addEntry(OHOS_CONTROL_LCD_FLASH, &lcdFlash, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdataSettings(setting); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + } + } + // 进行拍照 + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } +} + +/** + * @tc.name: Camera_Device_Hdi_V1_3_050 + * @tc.desc: meta + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) +{ + ASSERT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + ASSERT_NE(data, nullptr); + camera_metadata_item_t entry; + cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOVING_PHOTO, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (*entry.data.i32 == 1) { + cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); + cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( + cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); + ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + + // preview streamInfo + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + + // meta streamInfo + cameraTest->streamInfoMeta = std::make_shared(); + // meta extended streamInfo + OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo { + .type = static_cast( + OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_META), + .width = 0, + .height = 0, + .format = 0, + .dataspace = 0, + .bufferQueue = nullptr + }; + cameraTest->streamInfoMeta->extendedStreamInfos = {extendedStreamInfo}; + cameraTest->DefaultInfosMeta(cameraTest->streamInfoMeta); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoMeta); + + std::shared_ptr modeSetting = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t movingPhoto = static(OHOS_CAMERA_MOVING_PHOTO_ON); + modeSetting->addEntry(OHOS_CAMERA_MOVING_PHOTO, &movingPhoto, 1); + std::vector metaVec; + MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec); + cameraTest->cameraDeviceV1_1->UpdateSettings(metaVec); + + // capture streamInfo + cameraTest->streamInfoCapture = std::make_shared(); + cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); + + cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams( + OperationMode::NORMAL, cameraTest->abilityVec); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + sleep(UT_SECOND_TIMES); + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdMeta, cameraTest->captureIdMeta, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); + } + } +} + +/** + * @tc.name: Camera_Device_Hdi_V1_3_051 + * @tc.desc: OHOS_ABILITY_DEPTH_DATA_PROFILES + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_051, TestSize.Level1) +{ + EXPECT_NE(cameraTest->ability, nullptr); + common_metadata_header_t* data = cameraTest->ability->get(); + EXPECT_NE(data, nullptr); + camera_metadata_item_t entry; + + cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_DEPTH_DATA_PROFILES, &entry); + if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) { + printf("OHOS_ABILITY_DEPTH_DATA_PROFILES is not support"); + return; + } + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + CAMERA_LOGI("print tag i32 value start."); + printf("OHOS_ABILITY_DEPTH_DATA_PROFILES i32 value count %d\n", entry.count); + constexpr size_t step = 10; + std::stringstream ss; + for (size_t i = 0; i < entry.count; i++) { + ss << entry.data.i32[i] << " "; + if ((i != 0) && (i % step == 0 || i == entry.count - 1)) { + CAMERA_LOGI("%{public}s\n", ss.str().c_str()); + printf("OHOS_ABILITY_DEPTH_DATA_PROFILES %s\n", ss.str().c_str()); + ss.clear(); + ss.str(""); + } + } + CAMERA_LOGI("print tag i32 value end."); + } +} + +/** + * @tc.name: Camera_Device_Hdi_V1_3_052 + * @tc.desc: OHOS_CONTROL_DEPTH_DATA_ACCURACY + * @tc.size: MediumTest + * @tc.type: Function + */ +HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_052, TestSize.Level1) +{ + CAMERA_LOGI("test Camera_Device_Hdi_V1_3_052 start."); + cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); + cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( + cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); + EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); + + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + + cameraTest->streamInfoCapture = std::make_shared(); + cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); + + std::shared_ptr modeSetting = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t depthDataAccuracy = static_cast(OHOS_DEPTH_DATA_ACCURACY_RELATIVE); + modeSetting->addEntry(OHOS_CONTROL_DEPTH_DATA_ACCURACY, &depthDataAccuracy, 1); + std::vector metaVec; + MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec); + cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec); + + cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec); + ASSERT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR); + + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } \ No newline at end of file diff --git a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp index 6748313044..60b1efca31 100644 --- a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp @@ -187,6 +187,18 @@ void Test::DefaultSketch( infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE; } +void Test::DefaultMeta( + std::shared_ptr &infos) +{ + infos->v1_0.streamId_ = streamIdMeta; + infos->v1_0.width_ = metaWidth; + infos->v1_0.height_ = metaHeight; + infos->v1_0.format_ = previewFormat; + infos->v1_0.dataspace_ = UT_DATA_SIZE; + infos->v1_0.intent_ = StreamIntent::PREVIEW; + infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE; +} + void Test::DefaultInfosSketch( std::shared_ptr &infos) { @@ -199,6 +211,18 @@ void Test::DefaultInfosSketch( consumerMap_[StreamIntent::PREVIEW] = consumer_pre; } +void Test::DefaultInfosMeta( + std::shared_ptr &infos) +{ + DefaultMeta(infos); + std::shared_ptr consumer_pre = std::make_shared(); + infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) { + DumpImageFile(streamIdMeta, "yuv", addr, size); + }); + infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE); + consumerMap_[StreamIntent::PREVIEW] = consumer_pre; +} + void Test::DefaultInfosPreviewV1_2( std::shared_ptr &infos) { -- Gitee From 57c7db4036321c1fa77ae109ab560e0becbb7a90 Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Wed, 28 Aug 2024 13:00:37 +0000 Subject: [PATCH 0384/1485] update camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp. Signed-off-by: huangshengqing --- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 799abe973d..4e5868ce49 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -2036,7 +2036,7 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1) meta->addEntry(OHOS_CONTROL_LCD_FLASH, &lcdFlash, DATA_COUNT); std::vector setting; MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdataSettings(setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); } } @@ -2080,7 +2080,7 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) // meta extended streamInfo OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo { .type = static_cast( - OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_META), + OHOS::HDI::Camera::V1_3::EXTENDED_STREAM_INFO_META), .width = 0, .height = 0, .format = 0, @@ -2092,11 +2092,11 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoMeta); std::shared_ptr modeSetting = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t movingPhoto = static(OHOS_CAMERA_MOVING_PHOTO_ON); - modeSetting->addEntry(OHOS_CAMERA_MOVING_PHOTO, &movingPhoto, 1); + uint8_t movingPhoto = static_cast(OHOS_CAMERA_MOVING_PHOTO_ON); + modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1); std::vector metaVec; MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec); - cameraTest->cameraDeviceV1_1->UpdateSettings(metaVec); + cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec); // capture streamInfo cameraTest->streamInfoCapture = std::make_shared(); @@ -2112,8 +2112,8 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); cameraTest->StartCapture(cameraTest->streamIdMeta, cameraTest->captureIdMeta, false, true); cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch}; + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdMeta}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdMeta}; cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } } @@ -2127,19 +2127,18 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) */ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_051, TestSize.Level1) { - EXPECT_NE(cameraTest->ability, nullptr); + ASSERT_NE(cameraTest->ability, nullptr); common_metadata_header_t* data = cameraTest->ability->get(); - EXPECT_NE(data, nullptr); + ASSERT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_DEPTH_DATA_PROFILES, &entry); if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) { - printf("OHOS_ABILITY_DEPTH_DATA_PROFILES is not support"); + CAMERA_LOGI("OHOS_ABILITY_DEPTH_DATA_PROFILES is not support."); return; } if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { CAMERA_LOGI("print tag i32 value start."); - printf("OHOS_ABILITY_DEPTH_DATA_PROFILES i32 value count %d\n", entry.count); constexpr size_t step = 10; std::stringstream ss; for (size_t i = 0; i < entry.count; i++) { @@ -2167,7 +2166,7 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_052, TestSize.Level1) cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); - EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr); + ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr); cameraTest->streamInfoV1_1 = std::make_shared(); cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1); -- Gitee From e531ee38f0a3c2b4600e1d941aaf60bb3a744aa6 Mon Sep 17 00:00:00 2001 From: suxiaosu007 Date: Thu, 29 Aug 2024 16:44:56 +0800 Subject: [PATCH 0385/1485] codec testcase failed fixed Signed-off-by: suxiaosu007 --- codec/hal/src/codec_component_type_stub.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/codec/hal/src/codec_component_type_stub.c b/codec/hal/src/codec_component_type_stub.c index 556a7a225d..11c9d8dec1 100644 --- a/codec/hal/src/codec_component_type_stub.c +++ b/codec/hal/src/codec_component_type_stub.c @@ -633,10 +633,8 @@ static int32_t SerStubSetCallbacks(struct CodecComponentType *serviceImpl, struc ret = serviceImpl->SetCallbacks(serviceImpl, callback, appData); if (ret != HDF_SUCCESS) { CODEC_LOGE("call SetCallbacks function failed!"); - CodecCallbackTypeRelease(callback); return ret; } - CodecCallbackTypeRelease(callback); return ret; } -- Gitee From bd15a7af771016c5d70c889b55d1bbe2abce75fe Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Thu, 29 Aug 2024 09:12:27 +0000 Subject: [PATCH 0386/1485] update camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp. Signed-off-by: huangshengqing --- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 174 +++++++++--------- 1 file changed, 82 insertions(+), 92 deletions(-) diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 4e5868ce49..2779a440c8 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -2001,51 +2001,47 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1) ASSERT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LCD_FLASH, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - if (*entry.data.i32 == 1) { - cameraTest->intents = {PREVIEW, STILL_CAPTURE}; - cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); - // 开启预览流 - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0 && *entry.data.i32 == 1) { + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); + // 开启预览流 + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + // 使能环形补光 + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t lcdFlashDetection = 1; + meta->addEntry(OHOS_CONTROL_LCD_FLASH_DETECTION, &lcdFlashDetection, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + sleep(3); + if (cameraTest->deviceCallback->resultMeta == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult not be invoked."); + return; + } + // 返回结果是否需要环形补光 + common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get(); + if (data == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult be invoked but data was nullptr."); + return; + } + camera_metadata_item_t entry; + cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_LCD_FLASH_STATUS, &entry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0 && entry.data.i32[0] == 1) { // 使能环形补光 std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t lcdFlashDetection = 1; - meta->addEntry(OHOS_CONTROL_LCD_FLASH_DETECTION, &lcdFlashDetection, DATA_COUNT); + uint8_t lcdFlash = 1; + meta->addEntry(OHOS_CONTROL_LCD_FLASH, &lcdFlash, DATA_COUNT); std::vector setting; MetadataUtils::ConvertMetadataToVec(meta, setting); cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - sleep(3); - if (cameraTest->deviceCallback->resultMeta == nullptr) { - CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult not be invoked."); - return; - } - // 返回结果是否需要环形补光 - common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get(); - if (data == nullptr) { - CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult be invoked but data was nullptr."); - return; - } - camera_metadata_item_t entry; - cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_LCD_FLASH_STATUS, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - if (entry.data.i32[0] == 1) { - // 使能环形补光 - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t lcdFlash = 1; - meta->addEntry(OHOS_CONTROL_LCD_FLASH, &lcdFlash, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - } - } - // 进行拍照 - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } + // 进行拍照 + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } } @@ -2060,63 +2056,57 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1) ASSERT_NE(cameraTest->ability, nullptr); common_metadata_header_t* data = cameraTest->ability->get(); ASSERT_NE(data, nullptr); - camera_metadata_item_t entry; - cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOVING_PHOTO, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - if (*entry.data.i32 == 1) { - cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); - cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( - cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); - ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr); - ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3(); + cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3( + cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3); + ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr); + ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - // preview streamInfo - cameraTest->streamInfoV1_1 = std::make_shared(); - cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1); - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); + // preview streamInfo + cameraTest->streamInfoV1_1 = std::make_shared(); + cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1); - // meta streamInfo - cameraTest->streamInfoMeta = std::make_shared(); - // meta extended streamInfo - OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo { - .type = static_cast( - OHOS::HDI::Camera::V1_3::EXTENDED_STREAM_INFO_META), - .width = 0, - .height = 0, - .format = 0, - .dataspace = 0, - .bufferQueue = nullptr - }; - cameraTest->streamInfoMeta->extendedStreamInfos = {extendedStreamInfo}; - cameraTest->DefaultInfosMeta(cameraTest->streamInfoMeta); - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoMeta); - - std::shared_ptr modeSetting = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - uint8_t movingPhoto = static_cast(OHOS_CAMERA_MOVING_PHOTO_ON); - modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1); - std::vector metaVec; - MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec); - cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec); - - // capture streamInfo - cameraTest->streamInfoCapture = std::make_shared(); - cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); - cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); + // meta streamInfo + cameraTest->streamInfoMeta = std::make_shared(); + // meta extended streamInfo + OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo { + .type = static_cast( + OHOS::HDI::Camera::V1_3::EXTENDED_STREAM_INFO_META), + .width = 0, + .height = 0, + .format = 0, + .dataspace = 0, + .bufferQueue = nullptr + }; + cameraTest->streamInfoMeta->extendedStreamInfos = {extendedStreamInfo}; + cameraTest->DefaultInfosMeta(cameraTest->streamInfoMeta); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoMeta); - cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams( - OperationMode::NORMAL, cameraTest->abilityVec); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - sleep(UT_SECOND_TIMES); - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - cameraTest->StartCapture(cameraTest->streamIdMeta, cameraTest->captureIdMeta, false, true); - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdMeta}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdMeta}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); - } - } + std::shared_ptr modeSetting = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t movingPhoto = static_cast(OHOS_CAMERA_MOVING_PHOTO_ON); + modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1); + std::vector metaVec; + MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec); + cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec); + + // capture streamInfo + cameraTest->streamInfoCapture = std::make_shared(); + cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture); + cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture); + + cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams( + OperationMode::NORMAL, cameraTest->abilityVec); + EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); + sleep(UT_SECOND_TIMES); + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + cameraTest->StartCapture(cameraTest->streamIdMeta, cameraTest->captureIdMeta, false, true); + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdMeta}; + cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdMeta}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } /** -- Gitee From bb95062dcd21337379fc38842cc211a1a9857ba4 Mon Sep 17 00:00:00 2001 From: huangshengqing Date: Thu, 29 Aug 2024 09:21:57 +0000 Subject: [PATCH 0387/1485] update camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp. Signed-off-by: huangshengqing --- camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 2779a440c8..4c34b164ee 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -2001,7 +2001,8 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1) ASSERT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LCD_FLASH, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0 && *entry.data.i32 == 1) { + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (*entry.data.i32 != 1) return; cameraTest->intents = {PREVIEW, STILL_CAPTURE}; cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); // 开启预览流 @@ -2027,7 +2028,8 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1) } camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_LCD_FLASH_STATUS, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0 && entry.data.i32[0] == 1) { + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (entry.data.i32[0] != 1) return; // 使能环形补光 std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); uint8_t lcdFlash = 1; -- Gitee From 0284eaabfafd10859ef6ec1dbb0647ac05178933 Mon Sep 17 00:00:00 2001 From: xionglei Date: Thu, 29 Aug 2024 18:59:52 +0800 Subject: [PATCH 0388/1485] =?UTF-8?q?=E5=86=85=E5=AD=98=E6=B3=84=E6=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- .../service_common/wpa_common_cmd.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c index 5be325c259..7a7a13adba 100644 --- a/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c +++ b/wlan/wpa/interfaces/hdi_service/service_common/wpa_common_cmd.c @@ -478,22 +478,21 @@ int32_t WpaInterfaceAutoConnect(struct IWpaInterface *self, const char *ifName, return HDF_SUCCESS; } -static void GetWpaCmdStatus(uint8_t* dst, uint32_t* dstLen, char* src) +static bool GetWpaCmdStatus(uint8_t** dst, uint32_t* dstLen, char* src) { if (strcmp(src, "") != 0) { - dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); - if (dst == NULL) { + *dst = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (strlen(src) + 1)); + if (*dst == NULL) { HDF_LOGE("%{public}s OsalMemCalloc is NULL", __func__); *dstLen = 0; - return; + return false; } *dstLen = strlen(src); - if (strcpy_s((char*)dst, strlen(src) + 1, src) != EOK) { + if (strcpy_s((char*)(*dst), strlen(src) + 1, src) != EOK) { HDF_LOGE("%{public}s strcpy failed", __func__); - return; } } - return; + return true; } static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWpaCmdStatus *status) @@ -504,8 +503,10 @@ static void WpaProcessWifiStatus(struct WpaHalCmdStatus *halStatus, struct HdiWp } status->id = halStatus->id; status->freq = halStatus->freq; - GetWpaCmdStatus(status->keyMgmt, &(status->keyMgmtLen), halStatus->keyMgmt); - GetWpaCmdStatus(status->ssid, &(status->ssidLen), halStatus->ssid); + if (GetWpaCmdStatus(&(status->keyMgmt), &(status->keyMgmtLen), halStatus->keyMgmt) == false || + GetWpaCmdStatus(&(status->ssid), &(status->ssidLen), halStatus->ssid) == false) { + return; + } if (strcmp(halStatus->address, "") != 0) { HDF_LOGI("%{public}s key include address value=%{private}s", __func__, halStatus->address); uint8_t tmpAddress[ETH_ADDR_LEN + 1] = {0}; -- Gitee From f090d6e26834f98c6966beb7da0dd7b8b62a204c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A7=A6=E9=99=85=E7=BA=A2?= Date: Fri, 30 Aug 2024 02:33:05 +0000 Subject: [PATCH 0389/1485] fix test_request MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 秦际红 --- .../unittest/hal/src/usbd_request_test.cpp | 25 +++++++++++++++---- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/usb/test/unittest/hal/src/usbd_request_test.cpp b/usb/test/unittest/hal/src/usbd_request_test.cpp index bacb6a31b8..7eab730ff6 100644 --- a/usb/test/unittest/hal/src/usbd_request_test.cpp +++ b/usb/test/unittest/hal/src/usbd_request_test.cpp @@ -1750,8 +1750,11 @@ HWTEST_F(UsbdRequestTest, BulkCancel001, TestSize.Level1) uint8_t interfaceId = INTERFACEID_OK; uint8_t pointId = POINTID_DIR_IN; struct UsbPipe pipe = {interfaceId, pointId}; + auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::BulkCancel001 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); sptr usbdBulkCallback = new UsbdBulkCallbackTest(); - auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); + ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); HDF_LOGI("UsbdTransferTest::BulkCancel001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); ASSERT_EQ(ret, 0); ret = g_usbInterface->BulkCancel(dev, pipe); @@ -1775,8 +1778,11 @@ HWTEST_F(UsbdRequestTest, BulkCancel002, TestSize.Level1) uint8_t interfaceId = INTERFACEID_OK; uint8_t pointId = POINTID_DIR_IN; struct UsbPipe pipe = {interfaceId, pointId}; + auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::BulkCancel002 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); sptr usbdBulkCallback = new UsbdBulkCallbackTest(); - auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); + ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); HDF_LOGI("UsbdTransferTest::BulkCancel002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); ASSERT_EQ(ret, 0); dev.busNum = BUS_NUM_INVALID; @@ -1802,8 +1808,11 @@ HWTEST_F(UsbdRequestTest, BulkCancel003, TestSize.Level1) uint8_t interfaceId = INTERFACEID_OK; uint8_t pointId = POINTID_DIR_IN; struct UsbPipe pipe = {interfaceId, pointId}; + auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::BulkCancel003 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); sptr usbdBulkCallback = new UsbdBulkCallbackTest(); - auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); + ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); HDF_LOGI("UsbdTransferTest::BulkCancel003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); ASSERT_EQ(ret, 0); dev.devAddr = DEV_ADDR_INVALID; @@ -1829,8 +1838,11 @@ HWTEST_F(UsbdRequestTest, BulkCancel004, TestSize.Level1) uint8_t interfaceId = INTERFACEID_OK; uint8_t pointId = POINTID_DIR_IN; struct UsbPipe pipe = {interfaceId, pointId}; + auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::BulkCancel004 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); sptr usbdBulkCallback = new UsbdBulkCallbackTest(); - auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); + ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); ASSERT_EQ(ret, 0); dev.busNum = BUS_NUM_INVALID; @@ -1859,8 +1871,11 @@ HWTEST_F(UsbdRequestTest, BulkCancel005, TestSize.Level1) uint8_t interfaceId = INTERFACEID_OK; uint8_t pointId = POINTID_DIR_IN; struct UsbPipe pipe = {interfaceId, pointId}; + auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1); + HDF_LOGI("UsbdRequestTest::BulkCancel005 %{public}d ClaimInterface=%{public}d", __LINE__, ret); + ASSERT_EQ(0, ret); sptr usbdBulkCallback = new UsbdBulkCallbackTest(); - auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); + ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback); HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret); ASSERT_EQ(ret, 0); pipe.intfId = POINTID_INVALID; -- Gitee From 7486850a2cf41985cbe3b7a707e48c8ed13feef1 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 15:02:23 +0800 Subject: [PATCH 0390/1485] =?UTF-8?q?up=20down=20=E7=BD=91=E5=8D=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_ap_iface.cpp | 1 + wlan/chip/hdi_service/wifi_ap_iface.h | 1 + wlan/chip/hdi_service/wifi_chip_modes.cpp | 1 + wlan/chip/hdi_service/wifi_p2p_iface.cpp | 1 + wlan/chip/hdi_service/wifi_p2p_iface.h | 1 + wlan/chip/hdi_service/wifi_sta_iface.cpp | 1 + wlan/chip/hdi_service/wifi_sta_iface.h | 1 + 7 files changed, 7 insertions(+) diff --git a/wlan/chip/hdi_service/wifi_ap_iface.cpp b/wlan/chip/hdi_service/wifi_ap_iface.cpp index b7b4c6c1b5..873718fc15 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.cpp +++ b/wlan/chip/hdi_service/wifi_ap_iface.cpp @@ -21,6 +21,7 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { + WifiApIface::WifiApIface( const std::string& ifname, const std::vector& instances, const std::weak_ptr vendorHal, diff --git a/wlan/chip/hdi_service/wifi_ap_iface.h b/wlan/chip/hdi_service/wifi_ap_iface.h index 44dc215a1b..7312e3d9bf 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.h +++ b/wlan/chip/hdi_service/wifi_ap_iface.h @@ -28,6 +28,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { + class WifiApIface : public IChipIface { public: WifiApIface(const std::string& ifname, const std::vector& instances, diff --git a/wlan/chip/hdi_service/wifi_chip_modes.cpp b/wlan/chip/hdi_service/wifi_chip_modes.cpp index 985620722d..7ee33693a8 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.cpp +++ b/wlan/chip/hdi_service/wifi_chip_modes.cpp @@ -22,6 +22,7 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { + #define STA IfaceType::STA #define AP IfaceType::AP #define P2P IfaceType::P2P diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.cpp b/wlan/chip/hdi_service/wifi_p2p_iface.cpp index 511be1e764..1d2578eceb 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.cpp +++ b/wlan/chip/hdi_service/wifi_p2p_iface.cpp @@ -20,6 +20,7 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { + WifiP2pIface::WifiP2pIface( const std::string& ifname, const std::weak_ptr vendorHal, const std::weak_ptr ifaceUtil) diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.h b/wlan/chip/hdi_service/wifi_p2p_iface.h index cfac941f32..c85dffbe91 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.h +++ b/wlan/chip/hdi_service/wifi_p2p_iface.h @@ -28,6 +28,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { + class WifiP2pIface : public IChipIface { public: WifiP2pIface(const std::string& ifname, const std::weak_ptr vendorHal, diff --git a/wlan/chip/hdi_service/wifi_sta_iface.cpp b/wlan/chip/hdi_service/wifi_sta_iface.cpp index 25dd795172..3fe5e43064 100644 --- a/wlan/chip/hdi_service/wifi_sta_iface.cpp +++ b/wlan/chip/hdi_service/wifi_sta_iface.cpp @@ -22,6 +22,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { + WifiStaIface::WifiStaIface( const std::string& ifname, const std::weak_ptr vendorHal, diff --git a/wlan/chip/hdi_service/wifi_sta_iface.h b/wlan/chip/hdi_service/wifi_sta_iface.h index e9e42fc7fa..250caebbcc 100644 --- a/wlan/chip/hdi_service/wifi_sta_iface.h +++ b/wlan/chip/hdi_service/wifi_sta_iface.h @@ -29,6 +29,7 @@ namespace Wlan { namespace Chip { namespace V1_0 { + class WifiStaIface : public IChipIface { public: WifiStaIface(const std::string& ifname, const std::weak_ptr vendorHal, -- Gitee From a614621a421e712583053f8175ce0c10f414ecca Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:31:09 +0000 Subject: [PATCH 0391/1485] update wlan/chip/hdi_service/wifi_ap_iface.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_ap_iface.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_ap_iface.cpp b/wlan/chip/hdi_service/wifi_ap_iface.cpp index 873718fc15..779862cd35 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.cpp +++ b/wlan/chip/hdi_service/wifi_ap_iface.cpp @@ -21,7 +21,6 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { - WifiApIface::WifiApIface( const std::string& ifname, const std::vector& instances, const std::weak_ptr vendorHal, @@ -173,6 +172,13 @@ int32_t WifiApIface::SetTxPower(int32_t power) return HDF_ERR_NOT_SUPPORT; } +int32_t WifiApIface::SetIfaceState(bool state) +{ + if (ifaceUtil_.lock()->SetUpState(ifname_, state)) { + return HDF_SUCCESS; + } + return HDF_FAILURE; +} } } } -- Gitee From 3115df1e37fdaac9ab83337ffe434459acb8035c Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:32:28 +0000 Subject: [PATCH 0392/1485] update wlan/chip/hdi_service/wifi_ap_iface.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_ap_iface.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_ap_iface.h b/wlan/chip/hdi_service/wifi_ap_iface.h index 7312e3d9bf..2439ee7d3c 100644 --- a/wlan/chip/hdi_service/wifi_ap_iface.h +++ b/wlan/chip/hdi_service/wifi_ap_iface.h @@ -28,7 +28,6 @@ namespace Wlan { namespace Chip { namespace V1_0 { - class WifiApIface : public IChipIface { public: WifiApIface(const std::string& ifname, const std::vector& instances, @@ -56,6 +55,7 @@ public: int32_t EnablePowerMode(int32_t mode) override; int32_t SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable) override; int32_t SetTxPower(int32_t power) override; + int32_t SetIfaceState(bool state) override; private: std::string ifname_; -- Gitee From db050082f3eab944d9e3192f65ab63e6433043c8 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:33:55 +0000 Subject: [PATCH 0393/1485] update wlan/chip/hdi_service/wifi_chip_modes.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_chip_modes.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_chip_modes.cpp b/wlan/chip/hdi_service/wifi_chip_modes.cpp index 7ee33693a8..985620722d 100644 --- a/wlan/chip/hdi_service/wifi_chip_modes.cpp +++ b/wlan/chip/hdi_service/wifi_chip_modes.cpp @@ -22,7 +22,6 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { - #define STA IfaceType::STA #define AP IfaceType::AP #define P2P IfaceType::P2P -- Gitee From c327cd56b120dc9bc35f557b06ace2c6eb8890d6 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:34:56 +0000 Subject: [PATCH 0394/1485] update wlan/chip/hdi_service/wifi_p2p_iface.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_p2p_iface.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.cpp b/wlan/chip/hdi_service/wifi_p2p_iface.cpp index 1d2578eceb..0375d3d4b0 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.cpp +++ b/wlan/chip/hdi_service/wifi_p2p_iface.cpp @@ -20,7 +20,6 @@ namespace HDI { namespace Wlan { namespace Chip { namespace V1_0 { - WifiP2pIface::WifiP2pIface( const std::string& ifname, const std::weak_ptr vendorHal, const std::weak_ptr ifaceUtil) @@ -137,6 +136,10 @@ int32_t WifiP2pIface::SetTxPower(int32_t power) return HDF_ERR_NOT_SUPPORT; } +int32_t WifiP2pIface::SetIfaceState(bool state) +{ + return HDF_ERR_NOT_SUPPORT; +} } } } -- Gitee From 4966e43a722757e7f27b482fc227ffbb348b537e Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:35:53 +0000 Subject: [PATCH 0395/1485] update wlan/chip/hdi_service/wifi_p2p_iface.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_p2p_iface.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_p2p_iface.h b/wlan/chip/hdi_service/wifi_p2p_iface.h index c85dffbe91..e3c21de686 100644 --- a/wlan/chip/hdi_service/wifi_p2p_iface.h +++ b/wlan/chip/hdi_service/wifi_p2p_iface.h @@ -28,7 +28,6 @@ namespace Wlan { namespace Chip { namespace V1_0 { - class WifiP2pIface : public IChipIface { public: WifiP2pIface(const std::string& ifname, const std::weak_ptr vendorHal, @@ -54,6 +53,7 @@ public: int32_t EnablePowerMode(int32_t mode) override; int32_t SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable) override; int32_t SetTxPower(int32_t power) override; + int32_t SetIfaceState(bool state) override; private: std::string ifname_; -- Gitee From 40b829aa53ae017a67abc1d4cf83979877fc80d6 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:36:51 +0000 Subject: [PATCH 0396/1485] update wlan/chip/hdi_service/wifi_sta_iface.cpp. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_sta_iface.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_sta_iface.cpp b/wlan/chip/hdi_service/wifi_sta_iface.cpp index 3fe5e43064..7f1ea25fad 100644 --- a/wlan/chip/hdi_service/wifi_sta_iface.cpp +++ b/wlan/chip/hdi_service/wifi_sta_iface.cpp @@ -22,7 +22,6 @@ namespace Wlan { namespace Chip { namespace V1_0 { - WifiStaIface::WifiStaIface( const std::string& ifname, const std::weak_ptr vendorHal, @@ -214,6 +213,13 @@ int32_t WifiStaIface::SetTxPower(int32_t power) return HDF_FAILURE; } +int32_t WifiStaIface::SetIfaceState(bool state) +{ + if (ifaceUtil_.lock()->SetUpState(ifname_, state)) { + return HDF_SUCCESS; + } + return HDF_FAILURE; +} } } } -- Gitee From b2460b22e1f973f3bceecbbac5e0961bf0e83034 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:37:42 +0000 Subject: [PATCH 0397/1485] update wlan/chip/hdi_service/wifi_sta_iface.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_sta_iface.h | 1 + 1 file changed, 1 insertion(+) diff --git a/wlan/chip/hdi_service/wifi_sta_iface.h b/wlan/chip/hdi_service/wifi_sta_iface.h index 250caebbcc..68e5071401 100644 --- a/wlan/chip/hdi_service/wifi_sta_iface.h +++ b/wlan/chip/hdi_service/wifi_sta_iface.h @@ -55,6 +55,7 @@ public: int32_t EnablePowerMode(int32_t mode) override; int32_t SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable) override; int32_t SetTxPower(int32_t power) override; + int32_t SetIfaceState(bool state) override; private: std::set> GetEventCallbacks(); -- Gitee From 134e57176a6226dcdbc2d7a8d3fb3f3c14315ce6 Mon Sep 17 00:00:00 2001 From: xionglei Date: Fri, 30 Aug 2024 07:38:25 +0000 Subject: [PATCH 0398/1485] update wlan/chip/hdi_service/wifi_sta_iface.h. Signed-off-by: xionglei --- wlan/chip/hdi_service/wifi_sta_iface.h | 1 - 1 file changed, 1 deletion(-) diff --git a/wlan/chip/hdi_service/wifi_sta_iface.h b/wlan/chip/hdi_service/wifi_sta_iface.h index 68e5071401..b3f98cb3b3 100644 --- a/wlan/chip/hdi_service/wifi_sta_iface.h +++ b/wlan/chip/hdi_service/wifi_sta_iface.h @@ -29,7 +29,6 @@ namespace Wlan { namespace Chip { namespace V1_0 { - class WifiStaIface : public IChipIface { public: WifiStaIface(const std::string& ifname, const std::weak_ptr vendorHal, -- Gitee From 536ffe1973ab46746b0b8ddc2f463c97876919ed Mon Sep 17 00:00:00 2001 From: JillFred <14623865@qq.com> Date: Fri, 30 Aug 2024 17:04:07 +0800 Subject: [PATCH 0399/1485] delete unsupport ut Signed-off-by: JillFred <14623865@qq.com> --- .../hdi_image/codec_hdi_heif_encode_test.cpp | 76 ------------------- 1 file changed, 76 deletions(-) diff --git a/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp b/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp index a87c8c5ad8..d62470d095 100644 --- a/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp +++ b/codec/test/unittest/hdi_image/codec_hdi_heif_encode_test.cpp @@ -270,57 +270,6 @@ public: uint32_t filledLen_; }; -// [OK] primary image -HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_001, TestSize.Level1) -{ - ASSERT_TRUE(hdiHeifEncoder_ != nullptr); - ASSERT_TRUE(bufferMgr_ != nullptr); - ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); - inputImgs_.emplace_back(primaryImageItem); - int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); - ASSERT_EQ(ret, HDF_SUCCESS); - ASSERT_TRUE(filledLen_ > 0); -} - -// [OK] primary image + auxl image + thumnail + userdata -HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_002, TestSize.Level1) -{ - ASSERT_TRUE(hdiHeifEncoder_ != nullptr); - ASSERT_TRUE(bufferMgr_ != nullptr); - ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtRgba_); - ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); - ImageItem auxlImageItem = CreateImageItem(AUXILIARY_IMG, pixelFmtRgba_); - ASSERT_TRUE(SetValidNclxColor(auxlImageItem)); - ImageItem thumImageItem = CreateImageItem(THUMBNAIL_IMG, pixelFmtRgba_); - ASSERT_TRUE(SetValidNclxColor(thumImageItem)); - refs_.emplace_back(ItemRef { - .type = AUXL, - .auxType = "", - .from = auxlImageItem.id, - .to = { primaryImageItem.id } - }); - refs_.emplace_back(ItemRef { - .type = THMB, - .auxType = "", - .from = thumImageItem.id, - .to = { primaryImageItem.id } - }); - inputImgs_.emplace_back(primaryImageItem); - inputImgs_.emplace_back(auxlImageItem); - inputImgs_.emplace_back(thumImageItem); - MetaItem metaUserData = CreateMetaItem(USER_DATA); - refs_.emplace_back(ItemRef { - .type = CDSC, - .auxType = "", - .from = metaUserData.id, - .to = { primaryImageItem.id } - }); - inputMetas_.emplace_back(metaUserData); - int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); - ASSERT_EQ(ret, HDF_SUCCESS); - ASSERT_TRUE(filledLen_ > 0); -} - // [FAIL] auxl image only HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_003, TestSize.Level1) { @@ -639,31 +588,6 @@ HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_019, TestSize.Level ASSERT_EQ(filledLen_, 0); } -// [OK] primary image + gainmap image -HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_020, TestSize.Level1) -{ - ASSERT_TRUE(hdiHeifEncoder_ != nullptr); - ASSERT_TRUE(bufferMgr_ != nullptr); - ImageItem tmapImageItem = CreateImageItem(T_MAP, pixelFmtNv12_); - ASSERT_TRUE(SetPropeForTmap(tmapImageItem)); - ImageItem primaryImageItem = CreateImageItem(PRIMARY_IMG, pixelFmtNv12_); - ASSERT_TRUE(SetValidNclxColor(primaryImageItem)); - ImageItem gainMapImageItem = CreateImageItem(GAIN_MAP, pixelFmtNv12_); - ASSERT_TRUE(SetValidNclxColor(gainMapImageItem)); - refs_.emplace_back(ItemRef { - .type = DIMG, - .auxType = "", - .from = tmapImageItem.id, - .to = { primaryImageItem.id, gainMapImageItem.id } - }); - inputImgs_.emplace_back(tmapImageItem); - inputImgs_.emplace_back(primaryImageItem); - inputImgs_.emplace_back(gainMapImageItem); - int32_t ret = hdiHeifEncoder_->DoHeifEncode(inputImgs_, inputMetas_, refs_, output_, filledLen_); - ASSERT_EQ(ret, HDF_SUCCESS); - ASSERT_TRUE(filledLen_ > 0); -} - // [FAIL] Tmap image is configured in refs, but not included in inputImgs HWTEST_F(CodecHdiHeifEncodeTest, HdfCodecHdiDoHeifEncodeTest_021, TestSize.Level1) { -- Gitee From 798db11fa77fec8f09f224cf07450dd6a4687574 Mon Sep 17 00:00:00 2001 From: chao <2216846594@qq.com> Date: Sat, 31 Aug 2024 15:50:14 +0800 Subject: [PATCH 0400/1485] code hdi cleancode Signed-off-by: chao <2216846594@qq.com> --- codec/hal/src/codec_callback_type_proxy.c | 1 + codec/hal/src/codec_component_manager_proxy.c | 1 + codec/hal/src/codec_component_type_driver.c | 1 + codec/test/demo/heif/src/buffer_helper.cpp | 6 +++--- .../image_fuzzer/common/src/encode_buffer_helper.cpp | 4 +++- 5 files changed, 9 insertions(+), 4 deletions(-) diff --git a/codec/hal/src/codec_callback_type_proxy.c b/codec/hal/src/codec_callback_type_proxy.c index d69292ac33..36bde1a32b 100644 --- a/codec/hal/src/codec_callback_type_proxy.c +++ b/codec/hal/src/codec_callback_type_proxy.c @@ -255,6 +255,7 @@ struct CodecCallbackType *CodecCallbackTypeGet(struct HdfRemoteService *remote) } if (!HdfRemoteServiceSetInterfaceDesc(remote, "ohos.hdi.codec_service")) { + OsalMemFree(instance); CODEC_LOGE("failed to init interface desc"); return NULL; } diff --git a/codec/hal/src/codec_component_manager_proxy.c b/codec/hal/src/codec_component_manager_proxy.c index 7b268863f2..a3029890b0 100644 --- a/codec/hal/src/codec_component_manager_proxy.c +++ b/codec/hal/src/codec_component_manager_proxy.c @@ -102,6 +102,7 @@ static int32_t GetComponentCapabilityList(CodecCompCapability *capList, int32_t if (!HdfRemoteServiceWriteInterfaceToken(g_codecComponentManagerProxy.remoteOmx, data)) { CODEC_LOGE("write interface token failed"); + ReleaseSbuf(data, reply); return HDF_FAILURE; } diff --git a/codec/hal/src/codec_component_type_driver.c b/codec/hal/src/codec_component_type_driver.c index 0b2dfd45df..067217cdba 100644 --- a/codec/hal/src/codec_component_type_driver.c +++ b/codec/hal/src/codec_component_type_driver.c @@ -85,6 +85,7 @@ static int32_t HdfCodecComponentTypeDriverBind(struct HdfDeviceObject *deviceObj } int ret = HdfDeviceObjectSetInterfaceDesc(deviceObject, COMPONENT_MANAGER_SERVICE_DESC); if (ret != HDF_SUCCESS) { + OsalMemFree(omxcomponenttypeHost); HDF_LOGE("Failed to set interface desc"); return ret; } diff --git a/codec/test/demo/heif/src/buffer_helper.cpp b/codec/test/demo/heif/src/buffer_helper.cpp index 3b0f314570..866dacd02a 100644 --- a/codec/test/demo/heif/src/buffer_helper.cpp +++ b/codec/test/demo/heif/src/buffer_helper.cpp @@ -218,12 +218,12 @@ void BufferHelper::DumpBuffer(const string& filePath, const SharedBuffer& buffer if (addr != nullptr) { ofs.write(static_cast(addr), static_cast(buffer.filledLen)); ofs.close(); + if (munmap(addr, buffer.filledLen) != 0) { + HDF_LOGW("failed to unmap addr for dump buffer"); + } } else { HDF_LOGE("failed to map addr for dump buffer"); } - if (munmap(addr, buffer.filledLen) != 0) { - HDF_LOGW("failed to unmap addr for dump buffer"); - } } ByteWriter::~ByteWriter() diff --git a/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp b/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp index 23586b305a..06c4564e47 100644 --- a/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp +++ b/codec/test/fuzztest/image_fuzzer/common/src/encode_buffer_helper.cpp @@ -55,8 +55,8 @@ bool EncodeBufferHelper::InitialRgbaData(BufferHandle* handle, PixelFileInfo& pi errno_t ret = EOK; uint8_t* dataEnd = data + size -1; if (dataEnd < data + pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA * pixelInfo.displayHeight) { - return false; HDF_LOGI("Input Data length Not Enough"); + return false; } for (uint32_t i = 0; i < pixelInfo.displayHeight; i++) { ret = memcpy_s(dst, pixelInfo.alignedWidth * BYTES_PER_PIXEL_RBGA, data, @@ -139,11 +139,13 @@ SharedBuffer EncodeBufferHelper::CreateSharedBuffer(uint8_t* data, size_t size) return buffer; } if (dataEnd < data + totalSize) { + close(fd); return buffer; } errno_t ret = EOK; ret = memcpy_s(reinterpret_cast(addr), totalSize, data, totalSize); if (ret != EOK) { + close(fd); return buffer; } data += totalSize; -- Gitee From 0b45b35c25338fe3b2966363082950f780339c8f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 16:38:36 +0800 Subject: [PATCH 0401/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 3 +++ sensor/hdi_service/sensor_clients_manager.cpp | 4 +++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index a430b4dbe6..066d14c751 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -29,6 +29,7 @@ namespace { constexpr int64_t REPOPRT_TIME = 60000000000; static std::unordered_map firstTimestampMap_; static std::unordered_map lastTimestampMap_; + static std::unordered_map sensorDataCountMap_; } int32_t SensorCallbackVdi::OnDataEventVdi(const OHOS::HDI::Sensor::V1_1::HdfSensorEventsVdi& eventVdi) @@ -60,6 +61,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin { SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); + sensorDataCountMap_[event.sensorId]++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; @@ -76,6 +78,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); + st += "sensorDataCount=" + std::to_string(sensorDataCountMap_[event.sensorId]); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 1f03a728d9..38603f6374 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -483,7 +483,9 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& if (ret != HDF_SUCCESS) { HDF_LOGD("%{public}s Sensor OnDataEvent failed, error code is %{public}d", __func__, ret); } else { - result += std::to_string(serviceId) + " "; + static std::unordered_map> sensorReportCountMap_; + sensorReportCountMap_[sensorId][serviceId]++; + result += std::to_string(serviceId) + "-" + sensorReportCountMap_[sensorId][serviceId] + " "; } } return result; -- Gitee From dc9bc21c2140279c562191e76960a067c6f19947 Mon Sep 17 00:00:00 2001 From: zhanghang133 Date: Sat, 31 Aug 2024 17:19:14 +0800 Subject: [PATCH 0402/1485] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E8=84=9A=E6=9E=B6?= =?UTF-8?q?=E6=A3=80=E6=B5=8B=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhanghang133 --- .../hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp | 8 +- .../hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp | 86 ++++++++++++------- camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp | 2 +- 3 files changed, 63 insertions(+), 33 deletions(-) diff --git a/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp index 198b6b5d7d..2980018e95 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_tag_test_v1_3.cpp @@ -89,12 +89,16 @@ HWTEST_F(CameraHdiTagTestV1_3, Camera_Hdi_TAG_TEST_V1_3_001, TestSize.Level1) HWTEST_F(CameraHdiTagTestV1_3, Camera_Hdi_TAG_TEST_V1_3_002, TestSize.Level1) { CAMERA_LOGI("CameraHdiTagTestV1_3 Camera_Hdi_TAG_TEST_V1_3_002 start ..."); - EXPECT_NE(cameraTest->ability, nullptr); common_metadata_header_t* data = cameraTest->ability->get(); - EXPECT_NE(data, nullptr); + ASSERT_NE(data, nullptr); camera_metadata_item_t entry; int ret = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry); if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { + if (entry.count == 1) { + CAMERA_LOGI("OHOS_ABILITY_TRIPOD_DETECTION %{public}d\n", entry.data.i32[0]); + printf("OHOS_ABILITY_TRIPOD_DETECTION %d\n", entry.data.i32[0]); + return + } constexpr size_t step = 10; std::stringstream ss; for (size_t i = 0; i < entry.count; i++) { diff --git a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp index 4c34b164ee..79e64029c3 100644 --- a/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/camera_hdi_uttest_v1_3.cpp @@ -1943,48 +1943,74 @@ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_047, TestSize.Level1) cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } +void UpdateMetadata(std::shared_ptr cameraTest) +{ + std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + // 修改Zoom大于15x + float zoomRatio = 16.0f; + meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT); + // 使能脚架检测 + uint8_t tripoDetection = 1; + meta->addEntry(OHOS_CONTROL_TRIPOD_DETECTION, &tripoDetection, DATA_COUNT); + std::vector setting; + MetadataUtils::ConvertMetadataToVec(meta, setting); + cameraTest->cameraDeviceV1_3->UpdateSettings(setting); +} + /** * @tc.name: Camera_Device_Hdi_V1_3_048 - * @tc.desc: OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, OHOS_CONTROL_ZOOM_RATIO, PROFESSIONAL_PHOTO + * @tc.desc: OHOS_ABILITY_TRIPOD_DETECTION * @tc.size: MediumTest * @tc.type: Function */ HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_048, TestSize.Level1) { + CAMERA_LOGI("CameraHdiUtTestV1_3 Camera_Device_Hdi_V1_3_048 start."); // 查询是否支持脚架检测 - EXPECT_NE(cameraTest->ability, nullptr); common_metadata_header_t* data = cameraTest->ability->get(); - EXPECT_NE(data, nullptr); + ASSERT_NE(data, nullptr); camera_metadata_item_t entry; cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry); - if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) { - if (*entry.data.i32 == 1) { - cameraTest->imageDataSaveSwitch = SWITCH_ON; - cameraTest->intents = {PREVIEW, STILL_CAPTURE}; - cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); - std::shared_ptr meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); - // 修改Zoom大于15x - float zoomRatio = 15.0f; - meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT); - // 使能脚架检测 - uint8_t tripoDetection = 1; - meta->addEntry(OHOS_CONTROL_TRIPOD_DETECTION, &tripoDetection, DATA_COUNT); - // 使能脚架检测算法 - uint8_t tripodStablitationAlgorithm = 1; - meta->addEntry(OHOS_CONTROL_TRIPOD_STABLITATION, &tripodStablitationAlgorithm, DATA_COUNT); - std::vector setting; - MetadataUtils::ConvertMetadataToVec(meta, setting); - cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting); - EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc); - cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); - sleep(3); - // 进行拍照 - cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); - cameraTest->captureIds = {cameraTest->captureIdPreview}; - cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture}; - cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); - } + if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || entry.data.i32 == nullptr + || entry.count <= 0 || entry.data.i32[0] != 1) { + CAMERA_LOGI("OHOS_ABILITY_TRIPOD_DETECTION value error"); + return; } + cameraTest->intents = {PREVIEW, STILL_CAPTURE}; + cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE); + UpdateMetadata(cameraTest); + cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true); + sleep(3); + if (cameraTest->deviceCallback->resultMeta == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_048 onresult not be invoked."); + return; + } + common_metadata_header_t* resultData = cameraTest->deviceCallback->resultMeta->get(); + if (resultData == nullptr) { + CAMERA_LOGI("Camera_Device_Hdi_V1_3_048 onresult be invoked but data was nullptr."); + return; + } + camera_metadata_item_t statusEntry; + cameraTest->rc = FindCameraMetadataItem(resultData, OHOS_STATUS_TRIPOD_DETECTION_STATUS, &statusEntry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && statusEntry.data.u8 != nullptr && statusEntry.count > 0) { + CAMERA_LOGI("OHOS_STATUS_TRIPOD_DETECTION_STATUS value:%{public}d", statusEntry.data.u8[0]); + // 使能脚架检测算法 + meta = std::make_shared(ITEM_CAPACITY, DATA_CAPACITY); + uint8_t tripodStablitationAlgorithm = 1; + meta->addEntry(OHOS_CONTROL_TRIPOD_STABLITATION, &tripodStablitationAlgorithm, DATA_COUNT); + std::vector pointData; + MetadataUtils::ConvertMetadataToVec(meta, pointData); + cameraTest->cameraDeviceV1_3->UpdateSettings(pointData); + } + camera_metadata_item_t pointEntry; + cameraTest->rc = FindCameraMetadataItem(resultData, OHOS_STATUS_SKETCH_POINT, &pointEntry); + if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && pointEntry.data.f != nullptr && pointEntry.count > 0) { + CAMERA_LOGI("OHOS_STATUS_SKETCH_POINT x:%{public}f y:%{public}f", pointEntry.data.f[0], pointEntry.data.f[1]); + } + cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false); + cameraTest->captureIds = {cameraTest->captureIdPreview}; + cameraTest->streamIds = {cameraTest->streamIdCapture, cameraTest->streamIdPreview}; + cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds); } /** diff --git a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp index 60b1efca31..93bd412cc7 100644 --- a/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp +++ b/camera/test/hdi/v1_3/src/hdi_common_v1_3.cpp @@ -140,7 +140,7 @@ void Test::GetCameraMetadata(int cameraId) CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc); } MetadataUtils::ConvertVecToMetadata(abilityVec, ability); - EXPECT_NE(ability, nullptr); + ASSERT_NE(ability, nullptr); } void Test::Close() -- Gitee From 9bf032ae7d34e7dfe7bc3463fe34cb9a0e6abc8c Mon Sep 17 00:00:00 2001 From: yuzhiqiang Date: Sat, 31 Aug 2024 09:22:01 +0000 Subject: [PATCH 0403/1485] bulk interface compatible interrupt Signed-off-by: yuzhiqiang --- usb/hdi_service/src/usb_impl.cpp | 9 ++++++--- usb/hdi_service/src/usbd_function.cpp | 7 ++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/usb/hdi_service/src/usb_impl.cpp b/usb/hdi_service/src/usb_impl.cpp index bc7892fad4..efe36926e8 100644 --- a/usb/hdi_service/src/usb_impl.cpp +++ b/usb/hdi_service/src/usb_impl.cpp @@ -1469,7 +1469,8 @@ int32_t UsbImpl::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_ HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed.", __func__); return ret; } - if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { + if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || + (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { HDF_LOGE("%{public}s:invalid param", __func__); return HDF_ERR_INVALID_PARAM; } @@ -1514,7 +1515,8 @@ int32_t UsbImpl::BulkTransferReadwithLength(const UsbDev &dev, tbuf = nullptr; return ret; } - if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { + if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || + (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { HDF_LOGE("%{public}s:invalid param", __func__); free(tbuf); tbuf = nullptr; @@ -1549,7 +1551,8 @@ int32_t UsbImpl::BulkTransferWrite( HDF_LOGE("%{public}s:read timeout error", __func__); return ret; } - if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { + if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || + (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { HDF_LOGE("%{public}s:invalid param", __func__); return HDF_ERR_INVALID_PARAM; } diff --git a/usb/hdi_service/src/usbd_function.cpp b/usb/hdi_service/src/usbd_function.cpp index 0021283d44..e629569135 100644 --- a/usb/hdi_service/src/usbd_function.cpp +++ b/usb/hdi_service/src/usbd_function.cpp @@ -356,6 +356,7 @@ int32_t UsbdFunction::UsbdReadUdc(char* udcName, size_t len) } else { HDF_LOGW("%{public}s: fread len than expected", __func__); } + (void)fclose(fpRead); return HDF_FAILURE; } @@ -377,14 +378,14 @@ int32_t UsbdFunction::UsbdEnableDevice(int32_t funcs) char tmpName[UDC_NAME_MAX_LEN] = {0}; for (int32_t i = 0; i < WRITE_UDC_MAX_RETRY; i++) { - if (i != 0) { + if (i != 0 && ret != HDF_SUCCESS) { ret = SetDDKFunction(funcs); if (ret != HDF_SUCCESS) { UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT); UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME)); + usleep(WAIT_UDC_TIME); + continue; } - usleep(WAIT_UDC_TIME); - continue; } ret = UsbdWriteUdc(udcName, strlen(udcName)); if (ret != HDF_SUCCESS) { -- Gitee From 83ed3cdcb978fb89fe7ccfcbd5f875fbaf57c478 Mon Sep 17 00:00:00 2001 From: liuziwei Date: Sat, 31 Aug 2024 17:47:44 +0800 Subject: [PATCH 0404/1485] fix code Signed-off-by: liuziwei Change-Id: Icf87761e72119e7f3860617786e9c01624bebbf4 --- user_auth/hdi_service/service/user_auth_interface_service.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/user_auth/hdi_service/service/user_auth_interface_service.cpp b/user_auth/hdi_service/service/user_auth_interface_service.cpp index a9b28395c2..ad5e0544b6 100644 --- a/user_auth/hdi_service/service/user_auth_interface_service.cpp +++ b/user_auth/hdi_service/service/user_auth_interface_service.cpp @@ -1141,7 +1141,7 @@ int32_t UserAuthInterfaceService::DeleteUser(int32_t userId, const std::vector Date: Sat, 31 Aug 2024 19:40:15 +0800 Subject: [PATCH 0405/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_clients_manager.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 38603f6374..a8cd7207c3 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -485,7 +485,8 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& } else { static std::unordered_map> sensorReportCountMap_; sensorReportCountMap_[sensorId][serviceId]++; - result += std::to_string(serviceId) + "-" + sensorReportCountMap_[sensorId][serviceId] + " "; + result += std::to_string(serviceId) + "-" + std::to_string(sensorReportCountMap_[sensorId][serviceId]) + + " "; } } return result; -- Gitee From 28b7bfaa7542f29cc726eba33323b7d6b39abc92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 19:41:18 +0800 Subject: [PATCH 0406/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 066d14c751..05eac895d4 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -29,7 +29,6 @@ namespace { constexpr int64_t REPOPRT_TIME = 60000000000; static std::unordered_map firstTimestampMap_; static std::unordered_map lastTimestampMap_; - static std::unordered_map sensorDataCountMap_; } int32_t SensorCallbackVdi::OnDataEventVdi(const OHOS::HDI::Sensor::V1_1::HdfSensorEventsVdi& eventVdi) @@ -61,6 +60,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin { SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); + static std::unordered_map sensorDataCountMap_; sensorDataCountMap_[event.sensorId]++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { -- Gitee From 6fac2469ab4e358e3784e62c3aebcdaff90a4c8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 19:55:16 +0800 Subject: [PATCH 0407/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 5 ++++- sensor/hdi_service/sensor_clients_manager.cpp | 8 ++++++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 05eac895d4..09dabca6f7 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -61,7 +61,10 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap_; - sensorDataCountMap_[event.sensorId]++; + if (sensorDataCountMap_.find(event.sensorId) == sensorDataCountMap_.end()) { + sensorDataCountMap_.find(event.sensorId)->second = 0; + } + sensorDataCountMap_.find(event.sensorId)->second++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index a8cd7207c3..d1b02cddd6 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -485,8 +485,12 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& } else { static std::unordered_map> sensorReportCountMap_; sensorReportCountMap_[sensorId][serviceId]++; - result += std::to_string(serviceId) + "-" + std::to_string(sensorReportCountMap_[sensorId][serviceId]) + - " "; + if (sensorReportCountMap_[sensorId].find(serviceId) == sensorReportCountMap_[sensorId].end()) { + sensorReportCountMap_[sensorId].find(serviceId)->second = 0; + } + sensorReportCountMap_[sensorId].find(serviceId)->second++; + result += std::to_string(serviceId) + "-" + + std::to_string(sensorReportCountMap_[sensorId].find(serviceId)->second) + " "; } } return result; -- Gitee From a8d252c1df46d4fcd7988825aae99da07b1c95ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 19:56:17 +0800 Subject: [PATCH 0408/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 09dabca6f7..d60b39c1b6 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -81,7 +81,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); - st += "sensorDataCount=" + std::to_string(sensorDataCountMap_[event.sensorId]); + st += "sensorDataCount=" + std::to_string(sensorReportCountMap_[sensorId].find(serviceId)->second); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } -- Gitee From 0e999d2f6ceb8e7ae30dc0d29543dbadd0aeba5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:12:54 +0800 Subject: [PATCH 0409/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 6 +++--- sensor/hdi_service/sensor_clients_manager.cpp | 5 ++--- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index d60b39c1b6..4fa706a7f2 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -62,9 +62,9 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap_; if (sensorDataCountMap_.find(event.sensorId) == sensorDataCountMap_.end()) { - sensorDataCountMap_.find(event.sensorId)->second = 0; + sensorDataCountMap_.[event.sensorId] = 0; } - sensorDataCountMap_.find(event.sensorId)->second++; + sensorDataCountMap_.[event.sensorId]->second++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; @@ -81,7 +81,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); - st += "sensorDataCount=" + std::to_string(sensorReportCountMap_[sensorId].find(serviceId)->second); + st += "sensorDataCount=" + std::to_string(sensorDataCountMap_.[event.sensorId]); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index d1b02cddd6..702777bcf2 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -484,11 +484,10 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& HDF_LOGD("%{public}s Sensor OnDataEvent failed, error code is %{public}d", __func__, ret); } else { static std::unordered_map> sensorReportCountMap_; - sensorReportCountMap_[sensorId][serviceId]++; if (sensorReportCountMap_[sensorId].find(serviceId) == sensorReportCountMap_[sensorId].end()) { - sensorReportCountMap_[sensorId].find(serviceId)->second = 0; + sensorReportCountMap_[sensorId][serviceId] = 0; } - sensorReportCountMap_[sensorId].find(serviceId)->second++; + sensorReportCountMap_[sensorId][serviceId]++; result += std::to_string(serviceId) + "-" + std::to_string(sensorReportCountMap_[sensorId].find(serviceId)->second) + " "; } -- Gitee From 1b05d88e5916b91fdde76ff24308036f8f4a69d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:13:30 +0800 Subject: [PATCH 0410/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_clients_manager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 702777bcf2..334af40b46 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -489,7 +489,7 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& } sensorReportCountMap_[sensorId][serviceId]++; result += std::to_string(serviceId) + "-" + - std::to_string(sensorReportCountMap_[sensorId].find(serviceId)->second) + " "; + std::to_string(sensorReportCountMap_[sensorId][serviceId]) + " "; } } return result; -- Gitee From c3c9c6b5317ff4041efa607b3dd90e2082bf9231 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:14:10 +0800 Subject: [PATCH 0411/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 4fa706a7f2..d9ca847d17 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -64,7 +64,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (sensorDataCountMap_.find(event.sensorId) == sensorDataCountMap_.end()) { sensorDataCountMap_.[event.sensorId] = 0; } - sensorDataCountMap_.[event.sensorId]->second++; + sensorDataCountMap_.[event.sensorId]++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; -- Gitee From f7916d948fea758fe69d707b5234ee79ce31babf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:19:13 +0800 Subject: [PATCH 0412/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index d9ca847d17..6248f55e38 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -62,9 +62,9 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap_; if (sensorDataCountMap_.find(event.sensorId) == sensorDataCountMap_.end()) { - sensorDataCountMap_.[event.sensorId] = 0; + sensorDataCountMap_[event.sensorId] = 0; } - sensorDataCountMap_.[event.sensorId]++; + sensorDataCountMap_[event.sensorId]++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; @@ -81,7 +81,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); - st += "sensorDataCount=" + std::to_string(sensorDataCountMap_.[event.sensorId]); + st += "sensorDataCount=" + std::to_string(sensorDataCountMap_[event.sensorId]); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } -- Gitee From f422efb35ab84429c54d1adba5e781f52148d365 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:26:40 +0800 Subject: [PATCH 0413/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 8 +++++--- sensor/hdi_service/sensor_clients_manager.cpp | 8 +++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 6248f55e38..6ec064a6b1 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -61,10 +61,12 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap_; - if (sensorDataCountMap_.find(event.sensorId) == sensorDataCountMap_.end()) { + auto it = sensorDataCountMap_.find(event.sensorId); + if (it == sensorDataCountMap_.end()) { sensorDataCountMap_[event.sensorId] = 0; + it = sensorDataCountMap_.find(event.sensorId); } - sensorDataCountMap_[event.sensorId]++; + it->second++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; @@ -81,7 +83,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); - st += "sensorDataCount=" + std::to_string(sensorDataCountMap_[event.sensorId]); + st += "sensorDataCount=" + std::to_string(it->second); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 334af40b46..042893e69c 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -484,12 +484,14 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& HDF_LOGD("%{public}s Sensor OnDataEvent failed, error code is %{public}d", __func__, ret); } else { static std::unordered_map> sensorReportCountMap_; - if (sensorReportCountMap_[sensorId].find(serviceId) == sensorReportCountMap_[sensorId].end()) { + auto it = sensorReportCountMap_[sensorId].find(serviceId); + if (it == sensorReportCountMap_[sensorId].end()) { sensorReportCountMap_[sensorId][serviceId] = 0; + it = sensorReportCountMap_[sensorId].find(serviceId); } - sensorReportCountMap_[sensorId][serviceId]++; + it->second++; result += std::to_string(serviceId) + "-" + - std::to_string(sensorReportCountMap_[sensorId][serviceId]) + " "; + std::to_string(it->second) + " "; } } return result; -- Gitee From 8c1dd0aeee79017abd0a76c477f35fb898310a76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:27:29 +0800 Subject: [PATCH 0414/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_clients_manager.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 042893e69c..c40027a0de 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -490,8 +490,7 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& it = sensorReportCountMap_[sensorId].find(serviceId); } it->second++; - result += std::to_string(serviceId) + "-" + - std::to_string(it->second) + " "; + result += std::to_string(serviceId) + "-" + std::to_string(it->second) + " "; } } return result; -- Gitee From 185077cd9cd92b9a10528c02d690691041e9786b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:32:54 +0800 Subject: [PATCH 0415/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 6 +++--- sensor/hdi_service/sensor_clients_manager.cpp | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 6ec064a6b1..e2429cd4ad 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -63,10 +63,10 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin static std::unordered_map sensorDataCountMap_; auto it = sensorDataCountMap_.find(event.sensorId); if (it == sensorDataCountMap_.end()) { - sensorDataCountMap_[event.sensorId] = 0; - it = sensorDataCountMap_.find(event.sensorId); + sensorDataCountMap_[event.sensorId] = 1; + } else { + it->second++; } - it->second++; bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { firstTimestampMap_[event.sensorId] = event.timestamp; diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index c40027a0de..1e1465eae1 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -486,10 +486,10 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& static std::unordered_map> sensorReportCountMap_; auto it = sensorReportCountMap_[sensorId].find(serviceId); if (it == sensorReportCountMap_[sensorId].end()) { - sensorReportCountMap_[sensorId][serviceId] = 0; - it = sensorReportCountMap_[sensorId].find(serviceId); + sensorReportCountMap_[sensorId][serviceId] = 1; + } else { + it->second++; } - it->second++; result += std::to_string(serviceId) + "-" + std::to_string(it->second) + " "; } } -- Gitee From 8f255aa960806c3946f78d3f300b3ecfb46359e0 Mon Sep 17 00:00:00 2001 From: yangkan Date: Sat, 31 Aug 2024 20:34:16 +0800 Subject: [PATCH 0416/1485] =?UTF-8?q?composer=20TDD=E8=87=AA=E5=8A=A8?= =?UTF-8?q?=E5=8C=96=E9=85=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangkan --- display/composer/test/benchmark/BUILD.gn | 1 + display/composer/test/moduletest/BUILD.gn | 1 + display/composer/test/resource/ohos_test.xml | 65 ++++++++++++++++++++ display/composer/test/unittest/BUILD.gn | 2 + 4 files changed, 69 insertions(+) create mode 100644 display/composer/test/resource/ohos_test.xml diff --git a/display/composer/test/benchmark/BUILD.gn b/display/composer/test/benchmark/BUILD.gn index d644ebd901..e72840d36b 100644 --- a/display/composer/test/benchmark/BUILD.gn +++ b/display/composer/test/benchmark/BUILD.gn @@ -18,6 +18,7 @@ module_output_path = "drivers_peripheral_display/display" ohos_benchmarktest("hdf_display_benchmark_test") { module_out_path = module_output_path + resource_config_file = "./../resource/ohos_test.xml" sources = [ "display_benchmark_test.cpp" ] deps = [ "../common:disp_dev_hdi_test_common" ] include_dirs = [ diff --git a/display/composer/test/moduletest/BUILD.gn b/display/composer/test/moduletest/BUILD.gn index 50753fcc56..a9609e3842 100644 --- a/display/composer/test/moduletest/BUILD.gn +++ b/display/composer/test/moduletest/BUILD.gn @@ -29,6 +29,7 @@ ohos_moduletest("composer_mt") { defines = [] defines += display_defines module_out_path = module_output_path + resource_config_file = "./../resource/ohos_test.xml" sources = [ "hdi_device_test.cpp" ] include_dirs = [ "../common" ] deps = [ "../common:disp_dev_hdi_test_common" ] diff --git a/display/composer/test/resource/ohos_test.xml b/display/composer/test/resource/ohos_test.xml new file mode 100644 index 0000000000..f49b7e7468 --- /dev/null +++ b/display/composer/test/resource/ohos_test.xml @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/display/composer/test/unittest/BUILD.gn b/display/composer/test/unittest/BUILD.gn index 2eebb9964b..5fe10bdbef 100644 --- a/display/composer/test/unittest/BUILD.gn +++ b/display/composer/test/unittest/BUILD.gn @@ -29,6 +29,7 @@ config("module_private_config") { ohos_unittest("composer_ut") { module_out_path = module_output_path + resource_config_file = "./../resource/ohos_test.xml" sources = [ "hdi_composer_ut.cpp" ] include_dirs = [ "../common" ] deps = [ "../common:disp_dev_hdi_test_common" ] @@ -51,6 +52,7 @@ ohos_unittest("composer_ut") { ohos_unittest("composer_death_test") { module_out_path = module_output_path + resource_config_file = "./../resource/ohos_test.xml" sources = [ "hdi_death_test.cpp" ] include_dirs = [ "../common" ] deps = [ "../common:disp_dev_hdi_test_common" ] -- Gitee From ec5d902150d141aff54d31f82a392b4dac6acdbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:41:34 +0800 Subject: [PATCH 0417/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 6 +++--- sensor/hdi_service/sensor_clients_manager.cpp | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index e2429cd4ad..98485ec198 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -60,10 +60,10 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin { SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); - static std::unordered_map sensorDataCountMap_; + static std::unordered_map sensorDataCountMap; auto it = sensorDataCountMap_.find(event.sensorId); - if (it == sensorDataCountMap_.end()) { - sensorDataCountMap_[event.sensorId] = 1; + if (it == sensorDataCountMap.end()) { + sensorDataCountMap[event.sensorId] = 1; } else { it->second++; } diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 1e1465eae1..902cfbdafe 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -483,10 +483,10 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& if (ret != HDF_SUCCESS) { HDF_LOGD("%{public}s Sensor OnDataEvent failed, error code is %{public}d", __func__, ret); } else { - static std::unordered_map> sensorReportCountMap_; - auto it = sensorReportCountMap_[sensorId].find(serviceId); - if (it == sensorReportCountMap_[sensorId].end()) { - sensorReportCountMap_[sensorId][serviceId] = 1; + static std::unordered_map> sensorReportCountMap; + auto it = sensorReportCountMap[sensorId].find(serviceId); + if (it == sensorReportCountMap[sensorId].end()) { + sensorReportCountMap[sensorId][serviceId] = 1; } else { it->second++; } -- Gitee From 48370d8974996e98cfc745ef34b2fb5041889186 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:43:08 +0800 Subject: [PATCH 0418/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 98485ec198..7882f8c762 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -61,7 +61,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin SENSOR_TRACE; std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap; - auto it = sensorDataCountMap_.find(event.sensorId); + auto it = sensorDataCountMap.find(event.sensorId); if (it == sensorDataCountMap.end()) { sensorDataCountMap[event.sensorId] = 1; } else { -- Gitee From b4a176a72b592c2de130ffcb3377afd5151b5449 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:56:49 +0800 Subject: [PATCH 0419/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 5 ++++- sensor/hdi_service/sensor_clients_manager.cpp | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 7882f8c762..0bbe231d7f 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -27,6 +27,7 @@ namespace V2_0 { namespace { constexpr int32_t DATA_LEN = 256; constexpr int64_t REPOPRT_TIME = 60000000000; + constexpr int32_t INIT_DATA_COUNT = 1; static std::unordered_map firstTimestampMap_; static std::unordered_map lastTimestampMap_; } @@ -62,10 +63,12 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap; auto it = sensorDataCountMap.find(event.sensorId); + int32_t dataCount = INIT_DATA_COUNT; if (it == sensorDataCountMap.end()) { sensorDataCountMap[event.sensorId] = 1; } else { it->second++; + dataCount = it->second; } bool result = false; if (firstTimestampMap_[event.sensorId] == 0) { @@ -83,7 +86,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin if (result) { std::string st = {0}; DataToStr(st, event); - st += "sensorDataCount=" + std::to_string(it->second); + st += "sensorDataCount=" + std::to_string(dataCount); st += reportResult; HDF_LOGI("%{public}s: %{public}s", __func__, st.c_str()); } diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 902cfbdafe..86d16b8aa9 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -38,6 +38,7 @@ namespace { constexpr int64_t ERROR_INTERVAL = 0; constexpr int64_t STOP_INTERVAL = 0; constexpr int32_t INIT_CUR_COUNT = 0; + constexpr int32_t INIT_REPORT_COUNT = 1; } std::mutex SensorClientsManager::instanceMutex_; @@ -485,12 +486,14 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& } else { static std::unordered_map> sensorReportCountMap; auto it = sensorReportCountMap[sensorId].find(serviceId); + int32_t reportCount = INIT_REPORT_COUNT; if (it == sensorReportCountMap[sensorId].end()) { sensorReportCountMap[sensorId][serviceId] = 1; } else { it->second++; + reportCount = it->second; } - result += std::to_string(serviceId) + "-" + std::to_string(it->second) + " "; + result += std::to_string(serviceId) + "-" + std::to_string(reportCount) + " "; } } return result; -- Gitee From 7647da33ed0193498b9dbc318a2ed05eaa2f9557 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:57:31 +0800 Subject: [PATCH 0420/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 2 +- sensor/hdi_service/sensor_clients_manager.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 0bbe231d7f..3651f07989 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -65,7 +65,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin auto it = sensorDataCountMap.find(event.sensorId); int32_t dataCount = INIT_DATA_COUNT; if (it == sensorDataCountMap.end()) { - sensorDataCountMap[event.sensorId] = 1; + sensorDataCountMap[event.sensorId] = INIT_DATA_COUNT; } else { it->second++; dataCount = it->second; diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 86d16b8aa9..354a5f5048 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -488,7 +488,7 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& auto it = sensorReportCountMap[sensorId].find(serviceId); int32_t reportCount = INIT_REPORT_COUNT; if (it == sensorReportCountMap[sensorId].end()) { - sensorReportCountMap[sensorId][serviceId] = 1; + sensorReportCountMap[sensorId][serviceId] = INIT_REPORT_COUNT; } else { it->second++; reportCount = it->second; -- Gitee From 1e2aa9c470e161958f80cba0bbba6da19d065935 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=A2=81=E9=B9=8F=E8=BE=89?= Date: Sat, 31 Aug 2024 20:58:09 +0800 Subject: [PATCH 0421/1485] change123 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 梁鹏辉 --- sensor/hdi_service/sensor_callback_vdi.cpp | 4 ++-- sensor/hdi_service/sensor_clients_manager.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sensor/hdi_service/sensor_callback_vdi.cpp b/sensor/hdi_service/sensor_callback_vdi.cpp index 3651f07989..eed79893db 100644 --- a/sensor/hdi_service/sensor_callback_vdi.cpp +++ b/sensor/hdi_service/sensor_callback_vdi.cpp @@ -27,7 +27,7 @@ namespace V2_0 { namespace { constexpr int32_t DATA_LEN = 256; constexpr int64_t REPOPRT_TIME = 60000000000; - constexpr int32_t INIT_DATA_COUNT = 1; + constexpr int64_t INIT_DATA_COUNT = 1; static std::unordered_map firstTimestampMap_; static std::unordered_map lastTimestampMap_; } @@ -63,7 +63,7 @@ void SensorCallbackVdi::PrintData(const HdfSensorEvents &event, const std::strin std::unique_lock lock(timestampMapMutex_); static std::unordered_map sensorDataCountMap; auto it = sensorDataCountMap.find(event.sensorId); - int32_t dataCount = INIT_DATA_COUNT; + int64_t dataCount = INIT_DATA_COUNT; if (it == sensorDataCountMap.end()) { sensorDataCountMap[event.sensorId] = INIT_DATA_COUNT; } else { diff --git a/sensor/hdi_service/sensor_clients_manager.cpp b/sensor/hdi_service/sensor_clients_manager.cpp index 354a5f5048..d6c444878b 100644 --- a/sensor/hdi_service/sensor_clients_manager.cpp +++ b/sensor/hdi_service/sensor_clients_manager.cpp @@ -38,7 +38,7 @@ namespace { constexpr int64_t ERROR_INTERVAL = 0; constexpr int64_t STOP_INTERVAL = 0; constexpr int32_t INIT_CUR_COUNT = 0; - constexpr int32_t INIT_REPORT_COUNT = 1; + constexpr int64_t INIT_REPORT_COUNT = 1; } std::mutex SensorClientsManager::instanceMutex_; @@ -486,7 +486,7 @@ std::string SensorClientsManager::ReportEachClient(const V2_0::HdfSensorEvents& } else { static std::unordered_map> sensorReportCountMap; auto it = sensorReportCountMap[sensorId].find(serviceId); - int32_t reportCount = INIT_REPORT_COUNT; + int64_t reportCount = INIT_REPORT_COUNT; if (it == sensorReportCountMap[sensorId].end()) { sensorReportCountMap[sensorId][serviceId] = INIT_REPORT_COUNT; } else { -- Gitee From 27ec8b64d035f706df168ad371df1b3b8b87f78c Mon Sep 17 00:00:00 2001 From: yangkan Date: Sat, 31 Aug 2024 14:09:15 +0000 Subject: [PATCH 0422/1485] update display/composer/test/resource/ohos_test.xml. Signed-off-by: yangkan --- display/composer/test/resource/ohos_test.xml | 24 ++++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/display/composer/test/resource/ohos_test.xml b/display/composer/test/resource/ohos_test.xml index f49b7e7468..280e786b2a 100644 --- a/display/composer/test/resource/ohos_test.xml +++ b/display/composer/test/resource/ohos_test.xml @@ -18,48 +18,48 @@ \ No newline at end of file -- Gitee From 0ffed7a0cd11758d3c26e645a97fbada6f9061bd Mon Sep 17 00:00:00 2001 From: yangkan Date: Sat, 31 Aug 2024 14:27:29 +0000 Subject: [PATCH 0423/1485] update display/composer/test/resource/ohos_test.xml. Signed-off-by: yangkan --- display/composer/test/resource/ohos_test.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/display/composer/test/resource/ohos_test.xml b/display/composer/test/resource/ohos_test.xml index 280e786b2a..358fa3ca47 100644 --- a/display/composer/test/resource/ohos_test.xml +++ b/display/composer/test/resource/ohos_test.xml @@ -42,7 +42,7 @@