openharmony/ability_dmsfwk
1
0
Fork 0
mirror of https://gitee.com/openharmony/ability_dmsfwk synced 2024-11-23 06:20:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

可信超大函数整改

Browse Source 
issue: https://gitee.com/openharmony/ability_dmsfwk/issues/I7XHCX
Signed-off-by: hunili <lihucheng2@huawei.com>
This commit is contained in:
hunili 2023-08-24 15:26:24 +08:00
parent 0e843f73fd
commit 611733ec7e
11 changed files with 502 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
interfaces/kits/napi/continuation_manager/js_continuation_manager.cpp
View File

@ -18,7 +18,6 @@
#include <memory>
#include "base/continuationmgr_log.h"
#include "device_connect_status.h"
#include "distributed_ability_manager_client.h"
#include "js_runtime_utils.h"
#include "napi_common_util.h"
@ -482,33 +481,37 @@ NativeValue *JsContinuationManager::OnUpdateConnectStatus(NativeEngine &engine,
return result;
}
std::string JsContinuationManager::GetErrorInfo(NativeEngine &engine, NativeCallbackInfo &info, int32_t &token,
std::string &deviceId, DeviceConnectStatus &deviceConnectStatus)
{
if (info.argc != ARG_COUNT_THREE && info.argc != ARG_COUNT_FOUR) {
return "Parameter error. The type of \"number of parameters\" must be 3 or 4";
}
if (!ConvertFromJsValue(engine, info.argv[0], token)) {
return "Parameter error. The type of \"token\" must be number";
}
if (!ConvertFromJsValue(engine, info.argv[ARG_COUNT_ONE], deviceId) || deviceId.empty()) {
return "Parameter error. The type of \"deviceId\" must be string and not empty";
}
deviceConnectStatus = DeviceConnectStatus::IDLE;
if (!ConvertFromJsValue(engine, info.argv[ARG_COUNT_TWO], deviceConnectStatus)) {
return "Parameter error. The type of \"status\" must be DeviceConnectState";
}
if (static_cast<int32_t>(deviceConnectStatus) < static_cast<int32_t>(DeviceConnectStatus::IDLE) ||
static_cast<int32_t>(deviceConnectStatus) > static_cast<int32_t>(DeviceConnectStatus::DISCONNECTING)) {
HILOGE("deviceConnectStatus is invalid");
return "Parameter error. The type of \"status\" must be DeviceConnectState";
}
return std::string();
}
NativeValue* JsContinuationManager::OnUpdateContinuationState(NativeEngine &engine, NativeCallbackInfo &info)
{
HILOGD("called.");
int32_t token = -1;
std::string deviceId;
DeviceConnectStatus deviceConnectStatus;
std::string errInfo = [this, &engine, &info, &token, &deviceId, &deviceConnectStatus, &errInfo]() -> std::string {
if (info.argc != ARG_COUNT_THREE && info.argc != ARG_COUNT_FOUR) {
return "Parameter error. The type of \"number of parameters\" must be 3 or 4";
}
if (!ConvertFromJsValue(engine, info.argv[0], token)) {
return "Parameter error. The type of \"token\" must be number";
}
if (!ConvertFromJsValue(engine, info.argv[ARG_COUNT_ONE], deviceId) || deviceId.empty()) {
return "Parameter error. The type of \"deviceId\" must be string and not empty";
}
deviceConnectStatus = DeviceConnectStatus::IDLE;
if (!ConvertFromJsValue(engine, info.argv[ARG_COUNT_TWO], deviceConnectStatus)) {
return "Parameter error. The type of \"status\" must be DeviceConnectState";
}
if (static_cast<int32_t>(deviceConnectStatus) < static_cast<int32_t>(DeviceConnectStatus::IDLE) ||
static_cast<int32_t>(deviceConnectStatus) > static_cast<int32_t>(DeviceConnectStatus::DISCONNECTING)) {
HILOGE("deviceConnectStatus is invalid");
return "Parameter error. The type of \"status\" must be DeviceConnectState";
}
return std::string();
} ();
std::string errInfo = GetErrorInfo(engine, info, token, deviceId, deviceConnectStatus);
if (!errInfo.empty()) {
HILOGE("%{public}s", errInfo.c_str());
napi_throw(reinterpret_cast<napi_env>(&engine),
@ -542,19 +545,25 @@ NativeValue* JsContinuationManager::OnUpdateContinuationState(NativeEngine &engi
return result;
}
NativeValue *JsContinuationManager::OnStartDeviceManager(NativeEngine &engine, NativeCallbackInfo &info)
int32_t JsContinuationManager::CheckParamAndGetToken(NativeEngine &engine, NativeCallbackInfo &info, int32_t &token)
{
HILOGD("called.");
int32_t errCode = 0;
if (info.argc < ARG_COUNT_ONE) {
HILOGE("Params not match");
errCode = ERR_NOT_OK;
}
int32_t token = -1;
if (!errCode && !ConvertFromJsValue(engine, info.argv[0], token)) {
HILOGE("Parse token failed");
errCode = ERR_NOT_OK;
}
return errCode;
}
NativeValue *JsContinuationManager::OnStartDeviceManager(NativeEngine &engine, NativeCallbackInfo &info)
{
HILOGD("called.");
int32_t token = -1;
int32_t errCode = CheckParamAndGetToken(engine, info, token);
decltype(info.argc) unwrapArgc = ARG_COUNT_ONE;
std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
if (info.argc > ARG_COUNT_ONE && info.argv[ARG_COUNT_ONE]->TypeOf() == NATIVE_OBJECT) {
@ -598,36 +607,41 @@ NativeValue *JsContinuationManager::OnStartDeviceManager(NativeEngine &engine, N
return result;
}
std::string JsContinuationManager::GetErrorForStartContinuation(NativeEngine &engine, NativeCallbackInfo &info,
int32_t &token, int32_t &unwrapArgc, std::shared_ptr<ContinuationExtraParams> &continuationExtraParams)
{
if (info.argc < ARG_COUNT_ONE || info.argc > ARG_COUNT_THREE) {
return "Parameter error. The type of \"number of parameters\" must be greater than 1 and less than 4";
}
if (!ConvertFromJsValue(engine, info.argv[0], token)) {
return "Parameter error. The type of \"token\" must be number";
}
continuationExtraParams = std::make_shared<ContinuationExtraParams>();
if (info.argc > ARG_COUNT_ONE && info.argv[ARG_COUNT_ONE]->TypeOf() == NATIVE_OBJECT) {
HILOGI("StartContinuationDeviceManager options is used.");
if (!UnWrapContinuationExtraParams(reinterpret_cast<napi_env>(&engine),
reinterpret_cast<napi_value>(info.argv[ARG_COUNT_ONE]), continuationExtraParams)) {
return "Parameter error. The type of \"options\" must be ContinuationExtraParams";
}
unwrapArgc++;
}
return std::string();
}
NativeValue* JsContinuationManager::OnStartContinuationDeviceManager(NativeEngine &engine, NativeCallbackInfo &info)
{
HILOGD("called.");
int32_t token = -1;
decltype(info.argc) unwrapArgc = ARG_COUNT_ONE;
int32_t argc = ARG_COUNT_ONE;
std::shared_ptr<ContinuationExtraParams> continuationExtraParams;
std::string errInfo = [this, &engine, &info, &token, & unwrapArgc, &continuationExtraParams]() -> std::string {
if (info.argc < ARG_COUNT_ONE || info.argc > ARG_COUNT_THREE) {
return "Parameter error. The type of \"number of parameters\" must be greater than 1 and less than 4";
}
if (!ConvertFromJsValue(engine, info.argv[0], token)) {
return "Parameter error. The type of \"token\" must be number";
}
continuationExtraParams = std::make_shared<ContinuationExtraParams>();
if (info.argc > ARG_COUNT_ONE && info.argv[ARG_COUNT_ONE]->TypeOf() == NATIVE_OBJECT) {
HILOGI("StartContinuationDeviceManager options is used.");
if (!UnWrapContinuationExtraParams(reinterpret_cast<napi_env>(&engine),
reinterpret_cast<napi_value>(info.argv[ARG_COUNT_ONE]), continuationExtraParams)) {
return "Parameter error. The type of \"options\" must be ContinuationExtraParams";
}
unwrapArgc++;
}
return std::string();
} ();
std::string errInfo = GetErrorForStartContinuation(engine, info, token, argc, continuationExtraParams);
if (!errInfo.empty()) {
HILOGE("%{public}s", errInfo.c_str());
napi_throw(reinterpret_cast<napi_env>(&engine),
GenerateBusinessError(reinterpret_cast<napi_env>(&engine), PARAMETER_CHECK_FAILED, errInfo));
return engine.CreateUndefined();
}
decltype(info.argc) unwrapArgc = argc;
AsyncTask::CompleteCallback complete =
[this, token, continuationExtraParams, unwrapArgc](NativeEngine &engine, AsyncTask &task, int32_t status) {
napi_handle_scope scope = nullptr;
@ -635,7 +649,6 @@ NativeValue* JsContinuationManager::OnStartContinuationDeviceManager(NativeEngin
if (scope == nullptr) {
return;
}
int32_t errCode = (unwrapArgc == ARG_COUNT_ONE) ?
DistributedAbilityManagerClient::GetInstance().StartDeviceManager(token) :
DistributedAbilityManagerClient::GetInstance().StartDeviceManager(token, continuationExtraParams);
@ -645,10 +658,8 @@ NativeValue* JsContinuationManager::OnStartContinuationDeviceManager(NativeEngin
errCode = ErrorCodeReturn(errCode);
task.Reject(engine, CreateJsError(engine, errCode, ErrorMessageReturn(errCode)));
}
napi_close_handle_scope(reinterpret_cast<napi_env>(&engine), scope);
};
NativeValue* lastParam = (info.argc <= unwrapArgc) ? nullptr : info.argv[unwrapArgc];
NativeValue* result = nullptr;
AsyncTask::Schedule("JsContinuationManager::OnStartContinuationDeviceManager",

6
interfaces/kits/napi/continuation_manager/js_continuation_manager.h
View File

@ -19,6 +19,7 @@
#include <utility>
#include "continuation_extra_params.h"
#include "device_connect_status.h"
#include "js_device_selection_listener.h"
#include "native_engine/native_engine.h"
#include "nlohmann/json.hpp"
@ -54,12 +55,17 @@ private:
NativeValue* OnUnregisterDeviceSelectionCallback(NativeEngine &engine, NativeCallbackInfo &info);
NativeValue* OnUpdateConnectStatus(NativeEngine &engine, NativeCallbackInfo &info);
NativeValue* OnStartDeviceManager(NativeEngine &engine, NativeCallbackInfo &info);
int32_t CheckParamAndGetToken(NativeEngine &engine, NativeCallbackInfo &info, int32_t &token);
NativeValue* OnInitDeviceConnectStateObject(NativeEngine &engine, NativeCallbackInfo &info);
NativeValue* OnInitContinuationModeObject(NativeEngine &engine, NativeCallbackInfo &info);
static napi_status SetEnumItem(const napi_env& env, napi_value object, const char* name, int32_t value);
NativeValue* OnRegisterContinuation(NativeEngine &engine, NativeCallbackInfo &info);
NativeValue* OnUnregisterContinuation(NativeEngine &engine, NativeCallbackInfo &info);
NativeValue* OnUpdateContinuationState(NativeEngine &engine, NativeCallbackInfo &info);
std::string GetErrorInfo(NativeEngine &engine, NativeCallbackInfo &info, int32_t &token,
std::string &deviceId, DeviceConnectStatus &deviceConnectStatus);
std::string GetErrorForStartContinuation(NativeEngine &engine, NativeCallbackInfo &info,
int32_t &token, int32_t &unwrapArgc, std::shared_ptr<ContinuationExtraParams> &continuationExtraParams);
NativeValue* OnStartContinuationDeviceManager(NativeEngine &engine, NativeCallbackInfo &info);
static bool IsCallbackValid(NativeValue* listenerObj);

2
services/dtbschedmgr/include/distributedWant/distributed_want.h
View File

@ -199,6 +199,8 @@ public:
*/
static DistributedWant* ParseUri(const std::string& uri);
static bool CheckParams(const std::string& uri);
/**
* @description: Obtains the description of a URI in a DistributedWant.
* @return Returns the URI description in the DistributedWant.

3
services/dtbschedmgr/include/distributedWant/distributed_want_params.h
View File

@ -57,6 +57,9 @@ public:
static bool CompareInterface(const sptr<AAFwk::IInterface> iIt1, const sptr<AAFwk::IInterface> iIt2, int typeId);
static bool CompareNumberInterface(const sptr<AAFwk::IInterface> iIt1,
const sptr<AAFwk::IInterface> iIt2, int typeId);
static int GetDataType(const sptr<AAFwk::IInterface> iIt);
static int GetNumberDataType(const sptr<AAFwk::IInterface> iIt);

1
services/dtbschedmgr/include/distributed_sched_service.h
View File

@ -239,6 +239,7 @@ private:
const AccountInfo& accountInfo, int32_t flag, bool needQueryExtension);
int32_t SaveConnectToken(const OHOS::AAFwk::Want& want, const sptr<IRemoteObject>& connect);
void SetCleanMissionFlag(const OHOS::AAFwk::Want& want, int32_t missionId);
void RemoveConnectAbilityInfo(const std::string& deviceId);
std::shared_ptr<DSchedContinuation> dschedContinuation_;
std::map<sptr<IRemoteObject>, std::list<ConnectAbilitySession>> distributedConnectAbilityMap_;

3
services/dtbschedmgr/include/distributed_sched_stub.h
View File

@ -43,6 +43,7 @@ private:
int32_t ConnectRemoteAbilityInner(MessageParcel& data, MessageParcel& reply);
int32_t DisconnectRemoteAbilityInner(MessageParcel& data, MessageParcel& reply);
int32_t ConnectAbilityFromRemoteInner(MessageParcel& data, MessageParcel& reply);
int32_t ReadDataForConnect(MessageParcel& data, CallerInfo callerInfo, AccountInfo accountInfo);
int32_t DisconnectAbilityFromRemoteInner(MessageParcel& data, MessageParcel& reply);
int32_t NotifyProcessDiedFromRemoteInner(MessageParcel& data, MessageParcel& reply);
#ifdef SUPPORT_DISTRIBUTED_MISSION_MANAGER
@ -65,6 +66,8 @@ private:
int32_t ReleaseAbilityFromRemoteInner(MessageParcel& data, MessageParcel& reply);
int32_t StartRemoteFreeInstallInner(MessageParcel& data, MessageParcel& reply);
int32_t StartFreeInstallFromRemoteInner(MessageParcel& data, MessageParcel& reply);
int32_t ReadDataForFreeInstall(MessageParcel& data,
CallerInfo &callerInfo, AccountInfo &accountInfo, int64_t &taskId);
int32_t NotifyCompleteFreeInstallFromRemoteInner(MessageParcel& data, MessageParcel& reply);
#ifdef SUPPORT_DISTRIBUTED_FORM_SHARE
int32_t StartRemoteShareFormInner(MessageParcel& data, MessageParcel& reply);

24
services/dtbschedmgr/src/distributedWant/distributed_want.cpp
View File

@ -875,23 +875,29 @@ DistributedWant* DistributedWant::CloneOperation()
return want;
}
DistributedWant* DistributedWant::ParseUri(const std::string& uri)
bool DistributedWant::CheckParams(const std::string& uri)
{
if (uri.length() <= 0) {
return nullptr;
return false;
}
std::string head = WANT_HEADER;
std::string end = ";end";
if (uri.find(head) != 0) {
return nullptr;
if (uri.find(WANT_HEADER) != 0) {
return false;
}
if (uri.rfind(end) != (uri.length() - end.length())) {
return false;
}
return true;
}
DistributedWant* DistributedWant::ParseUri(const std::string& uri)
{
if (!CheckParams(uri)) {
return nullptr;
}
bool ret = true;
std::string content;
std::size_t pos;
std::size_t begin = head.length();
std::size_t begin = WANT_HEADER.length();
ElementName element;
DistributedWant* want = new (std::nothrow) DistributedWant();
if (want == nullptr) {
@ -902,7 +908,7 @@ DistributedWant* DistributedWant::ParseUri(const std::string& uri)
pos = uri.find_first_of(";", begin);
do {
if (pos != std::string::npos) {
content = uri.substr(begin, pos - begin);
std::string content = uri.substr(begin, pos - begin);
if (content.compare("PICK") == 0) {
want = new (std::nothrow) DistributedWant();
if (want == nullptr) {
@ -925,8 +931,6 @@ DistributedWant* DistributedWant::ParseUri(const std::string& uri)
}
} while (true);
if (inPicker) {
if (baseWant->GetBundle().empty()) {
}
want = baseWant;
}
if (ret) {

38
services/dtbschedmgr/src/distributedWant/distributed_want_params.cpp
View File

@ -305,22 +305,11 @@ sptr<IInterface> DistributedWantParams::GetInterfaceByType(int typeId, const std
return nullptr;
}
bool DistributedWantParams::CompareInterface(const sptr<IInterface> iIt1, const sptr<IInterface> iIt2, int typeId)
bool DistributedWantParams::CompareNumberInterface(const sptr<IInterface> iIt1,
const sptr<IInterface> iIt2, int typeId)
{
bool flag = false;
switch (typeId) {
case VALUE_TYPE_BOOLEAN:
flag = static_cast<AAFwk::Boolean*>(AAFwk::IBoolean::Query(iIt1))
->Equals(*(static_cast<AAFwk::Boolean*>(AAFwk::IBoolean::Query(iIt1))));
break;
case VALUE_TYPE_BYTE:
flag = static_cast<AAFwk::Byte*>(AAFwk::IByte::Query(iIt1))
->Equals(*(static_cast<AAFwk::Byte*>(AAFwk::IByte::Query(iIt1))));
break;
case VALUE_TYPE_CHAR:
flag = static_cast<AAFwk::Char*>(AAFwk::IChar::Query(iIt1))
->Equals(*(static_cast<AAFwk::Char*>(AAFwk::IChar::Query(iIt1))));
break;
case VALUE_TYPE_SHORT:
flag = static_cast<AAFwk::Short*>(AAFwk::IShort::Query(iIt1))
->Equals(*(static_cast<AAFwk::Short*>(AAFwk::IShort::Query(iIt1))));
@ -341,6 +330,28 @@ bool DistributedWantParams::CompareInterface(const sptr<IInterface> iIt1, const
flag = static_cast<AAFwk::Double*>(AAFwk::IDouble::Query(iIt1))
->Equals(*(static_cast<AAFwk::Double*>(AAFwk::IDouble::Query(iIt1))));
break;
default:
break;
}
return flag;
}
bool DistributedWantParams::CompareInterface(const sptr<IInterface> iIt1, const sptr<IInterface> iIt2, int typeId)
{
bool flag = false;
switch (typeId) {
case VALUE_TYPE_BOOLEAN:
flag = static_cast<AAFwk::Boolean*>(AAFwk::IBoolean::Query(iIt1))
->Equals(*(static_cast<AAFwk::Boolean*>(AAFwk::IBoolean::Query(iIt1))));
break;
case VALUE_TYPE_BYTE:
flag = static_cast<AAFwk::Byte*>(AAFwk::IByte::Query(iIt1))
->Equals(*(static_cast<AAFwk::Byte*>(AAFwk::IByte::Query(iIt1))));
break;
case VALUE_TYPE_CHAR:
flag = static_cast<AAFwk::Char*>(AAFwk::IChar::Query(iIt1))
->Equals(*(static_cast<AAFwk::Char*>(AAFwk::IChar::Query(iIt1))));
break;
case VALUE_TYPE_STRING:
flag = static_cast<AAFwk::String*>(AAFwk::IString::Query(iIt1))
->Equals(*(static_cast<AAFwk::String*>(AAFwk::IString::Query(iIt1))));
@ -354,6 +365,7 @@ bool DistributedWantParams::CompareInterface(const sptr<IInterface> iIt1, const
->Equals(*(static_cast<DistributedWantParamWrapper*>(IDistributedWantParams::Query(iIt1))));
break;
default:
flag = CompareNumberInterface(iIt1, iIt2, typeId);
break;
}
return flag;

25
services/dtbschedmgr/src/distributed_sched_service.cpp
View File

@ -1695,15 +1695,8 @@ int32_t DistributedSchedService::NotifyProcessDiedFromRemote(const CallerInfo& c
return errCode;
}
void DistributedSchedService::ProcessDeviceOffline(const std::string& deviceId)
void DistributedSchedService::RemoveConnectAbilityInfo(const std::string& deviceId)
{
HILOGI("ProcessDeviceOffline called");
std::string localDeviceId;
if (!GetLocalDeviceId(localDeviceId) || !CheckDeviceId(localDeviceId, deviceId)) {
HILOGE("ProcessDeviceOffline check deviceId failed");
return;
}
{
std::lock_guard<std::mutex> autoLock(distributedLock_);
for (auto iter = distributedConnectAbilityMap_.begin(); iter != distributedConnectAbilityMap_.end();) {
@ -1748,6 +1741,17 @@ void DistributedSchedService::ProcessDeviceOffline(const std::string& deviceId)
}
}
}
}
void DistributedSchedService::ProcessDeviceOffline(const std::string& deviceId)
{
HILOGI("ProcessDeviceOffline called");
std::string localDeviceId;
if (!GetLocalDeviceId(localDeviceId) || !CheckDeviceId(localDeviceId, deviceId)) {
HILOGE("ProcessDeviceOffline check deviceId failed");
return;
}
RemoveConnectAbilityInfo(deviceId);
ProcessCalleeOffline(deviceId);
ProcessFreeInstallOffline(deviceId);
}
@ -2051,13 +2055,11 @@ int32_t DistributedSchedService::StartRemoteFreeInstall(const OHOS::AAFwk::Want&
HILOGE("check deviceId failed");
return INVALID_PARAMETERS_ERR;
}
sptr<IDistributedSched> remoteDms = GetRemoteDms(deviceId);
if (remoteDms == nullptr) {
HILOGE("get remoteDms failed");
return INVALID_PARAMETERS_ERR;
}
if (dmsCallbackTask_ == nullptr) {
HILOGE("callbackTask object null!");
return INVALID_REMOTE_PARAMETERS_ERR;
@ -2087,8 +2089,7 @@ int32_t DistributedSchedService::StartRemoteFreeInstall(const OHOS::AAFwk::Want&
}
AAFwk::Want* newWant = const_cast<Want*>(&want);
newWant->SetParam(DMS_SRC_NETWORK_ID, localDeviceId);
FreeInstallInfo info = {.want = *newWant, .requestCode = requestCode, .callerInfo = callerInfo,
.accountInfo = accountInfo};
FreeInstallInfo info = {*newWant, requestCode, callerInfo, accountInfo};
int32_t result = remoteDms->StartFreeInstallFromRemote(info, taskId);
if (result != ERR_OK) {
HILOGE("result = %{public}d", result);

51
services/dtbschedmgr/src/distributed_sched_stub.cpp
View File

@ -546,6 +546,18 @@ int32_t DistributedSchedStub::DisconnectRemoteAbilityInner(MessageParcel& data,
PARCEL_WRITE_REPLY_NOERROR(reply, Int32, result);
}
int32_t DistributedSchedStub::ReadDataForConnect(MessageParcel& data, CallerInfo callerInfo, AccountInfo accountInfo)
{
PARCEL_READ_HELPER(data, Int32, callerInfo.uid);
PARCEL_READ_HELPER(data, Int32, callerInfo.pid);
PARCEL_READ_HELPER(data, String, callerInfo.sourceDeviceId);
callerInfo.callerType = CALLER_TYPE_HARMONY;
accountInfo.accountType = data.ReadInt32();
PARCEL_READ_HELPER(data, StringVector, &accountInfo.groupIdList);
callerInfo.callerAppId = data.ReadString();
return ERR_NONE;
}
int32_t DistributedSchedStub::ConnectAbilityFromRemoteInner(MessageParcel& data, MessageParcel& reply)
{
if (!CheckCallingUid()) {
@ -566,14 +578,11 @@ int32_t DistributedSchedStub::ConnectAbilityFromRemoteInner(MessageParcel& data,
cmpAbilityInfo->ConvertToAbilityInfo(abilityInfo);
sptr<IRemoteObject> connect = data.ReadRemoteObject();
CallerInfo callerInfo;
PARCEL_READ_HELPER(data, Int32, callerInfo.uid);
PARCEL_READ_HELPER(data, Int32, callerInfo.pid);
PARCEL_READ_HELPER(data, String, callerInfo.sourceDeviceId);
callerInfo.callerType = CALLER_TYPE_HARMONY;
AccountInfo accountInfo;
accountInfo.accountType = data.ReadInt32();
PARCEL_READ_HELPER(data, StringVector, &accountInfo.groupIdList);
callerInfo.callerAppId = data.ReadString();
int32_t result = ReadDataForConnect(data, callerInfo, accountInfo);
if (result != ERR_NONE) {
return result;
}
std::string extraInfo = data.ReadString();
if (extraInfo.empty()) {
HILOGD("extra info is empty!");
@ -586,7 +595,7 @@ int32_t DistributedSchedStub::ConnectAbilityFromRemoteInner(MessageParcel& data,
std::string package = abilityInfo.bundleName;
std::string deviceId = abilityInfo.deviceId;
int64_t begin = GetTickCount();
int32_t result = ConnectAbilityFromRemote(*want, abilityInfo, connect, callerInfo, accountInfo);
result = ConnectAbilityFromRemote(*want, abilityInfo, connect, callerInfo, accountInfo);
BehaviorEventParam eventParam = { EventCallingType::REMOTE, BehaviorEvent::CONNECT_REMOTE_ABILITY, result,
want->GetElement().GetBundleName(), want->GetElement().GetAbilityName(), callerInfo.uid };
DmsHiSysEventReport::ReportBehaviorEvent(eventParam);
@ -1165,6 +1174,19 @@ int32_t DistributedSchedStub::StartRemoteFreeInstallInner(MessageParcel& data, M
return ERR_NONE;
}
int32_t DistributedSchedStub::ReadDataForFreeInstall(MessageParcel& data, CallerInfo &callerInfo,
AccountInfo &accountInfo, int64_t &taskId)
{
callerInfo.callerType = CALLER_TYPE_HARMONY;
PARCEL_READ_HELPER(data, Int32, callerInfo.uid);
PARCEL_READ_HELPER(data, String, callerInfo.sourceDeviceId);
accountInfo.accountType = data.ReadInt32();
PARCEL_READ_HELPER(data, StringVector, &accountInfo.groupIdList);
callerInfo.callerAppId = data.ReadString();
PARCEL_READ_HELPER(data, Int64, taskId);
return ERR_NONE;
}
int32_t DistributedSchedStub::StartFreeInstallFromRemoteInner(MessageParcel& data, MessageParcel& reply)
{
if (!CheckCallingUid()) {
@ -1178,15 +1200,12 @@ int32_t DistributedSchedStub::StartFreeInstallFromRemoteInner(MessageParcel& dat
}
int64_t begin = GetTickCount();
CallerInfo callerInfo = {.accessToken = 0};
callerInfo.callerType = CALLER_TYPE_HARMONY;
AccountInfo accountInfo = {};
int64_t taskId = 0;
PARCEL_READ_HELPER(data, Int32, callerInfo.uid);
PARCEL_READ_HELPER(data, String, callerInfo.sourceDeviceId);
accountInfo.accountType = data.ReadInt32();
PARCEL_READ_HELPER(data, StringVector, &accountInfo.groupIdList);
callerInfo.callerAppId = data.ReadString();
PARCEL_READ_HELPER(data, Int64, taskId);
int32_t result = ReadDataForFreeInstall(data, callerInfo, accountInfo, taskId);
if (result != ERR_NONE) {
return result;
}
shared_ptr<DistributedWant> cmpDstbWant(data.ReadParcelable<DistributedWant>());
shared_ptr<AAFwk::Want> cmpWant = nullptr;
if (cmpDstbWant != nullptr) {
@ -1211,7 +1230,7 @@ int32_t DistributedSchedStub::StartFreeInstallFromRemoteInner(MessageParcel& dat
info.want.SetParam(PARAM_FREEINSTALL_APPID, callerInfo.callerAppId);
info.want.SetParam(
PARAM_FREEINSTALL_BUNDLENAMES, (*cmpWant).GetStringArrayParam(CMPT_PARAM_FREEINSTALL_BUNDLENAMES));
int32_t result = StartFreeInstallFromRemote(info, taskId);
result = StartFreeInstallFromRemote(info, taskId);
HILOGI("result = %{public}d", result);
PARCEL_WRITE_HELPER(reply, Int32, result);
int64_t end = GetTickCount();

634
services/dtbschedmgr/test/unittest/distributedWant/distributed_want_test.cpp
View File

@ -81,6 +81,14 @@ public:
std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
void AddStringParams(DistributedWant &want,
std::map<std::string, std::string> &keys, int loop, unsigned int flag) const;
void TestStringForParseUri(std::string uri,
std::string keyString, std::size_t &length, std::string valueStringOrigin);
void TestFloatForParseUri(std::string uri,
std::string keyFloat, std::size_t &length, float valueFloatOrigin);
void TestFloatArrayForParseUri(std::string uri,
std::string keyFloatArray, std::size_t &length, std::vector<float> valueFloatArrayOrigin);
void TestStringArrayForParseUri(std::string uri,
std::string keyStringArray, std::size_t &length, std::vector<std::string> valueStringArrayOrigin);
std::string boolType = "bool";
std::string boolArrayType = "boolArray";
@ -153,56 +161,20 @@ HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_01
want.SetAction("Action");
want.AddEntity("Entity1");
want.SetParam(boolType, true);
std::vector<bool> bv;
bv.emplace_back(true);
bv.emplace_back(false);
want.SetParam(boolArrayType, bv);
want.SetParam(byteType, 1);
std::vector<byte> byv;
byv.emplace_back(2);
byv.emplace_back(3);
want.SetParam(byteArrayType, byv);
want.SetParam(charType, 6);
std::vector<zchar> chv;
chv.emplace_back('\n');
chv.emplace_back('p');
chv.emplace_back('i');
want.SetParam(charArrayType, chv);
want.SetParam(shortType, 444);
std::vector<short> shv;
shv.emplace_back(111);
shv.emplace_back(222);
shv.emplace_back(333);
want.SetParam(shortArrayType, shv);
want.SetParam(intType, 1111);
std::vector<int> inv;
inv.emplace_back(1111);
inv.emplace_back(2222);
inv.emplace_back(3333);
inv.emplace_back(4444);
want.SetParam(intArrayType, inv);
want.SetParam(longType, 12345);
std::vector<long> lgv;
lgv.emplace_back(1111);
lgv.emplace_back(2222);
lgv.emplace_back(3333);
lgv.emplace_back(4444);
want.SetParam(longArrayType, lgv);
want.SetParam(floatType, 1.1);
std::vector<float> ftv;
ftv.emplace_back(1111.1);
ftv.emplace_back(2222.2);
ftv.emplace_back(3333.3);
ftv.emplace_back(4444.4);
want.SetParam(floatArrayType, ftv);
want.SetParam(doubleType, 1.11);
want.SetParam(stringType, std::string("string..."));
std::vector<double> dbv;
dbv.emplace_back(1111.11);
dbv.emplace_back(2222.22);
dbv.emplace_back(3333.33);
dbv.emplace_back(4444.44);
want.SetParam(doubleArrayType, dbv);
want.SetParam(stringType, std::string("string..."));
std::vector<std::string> strv;
strv.emplace_back("1111.11");
strv.emplace_back("2222.22");
@ -217,31 +189,78 @@ HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_01
EXPECT_STREQ(want.GetAction().c_str(), dstbWant.GetAction().c_str());
EXPECT_EQ(want.GetEntities().size(), dstbWant.GetEntities().size());
EXPECT_EQ(want.GetBoolParam(boolType, false), dstbWant.GetBoolParam(boolType, true));
EXPECT_EQ(want.GetBoolArrayParam(boolArrayType).size(), dstbWant.GetBoolArrayParam(boolArrayType).size());
EXPECT_EQ(want.GetByteParam(byteType, 0), dstbWant.GetByteParam(byteType, 0));
EXPECT_EQ(want.GetByteArrayParam(byteArrayType).size(), dstbWant.GetByteArrayParam(byteArrayType).size());
EXPECT_EQ(want.GetCharParam(charType, 0), dstbWant.GetCharParam(charType, 0));
EXPECT_EQ(want.GetCharArrayParam(charArrayType).size(), dstbWant.GetCharArrayParam(charArrayType).size());
EXPECT_EQ(want.GetShortParam(shortType, 0), dstbWant.GetShortParam(shortType, 0));
EXPECT_EQ(want.GetShortArrayParam(shortArrayType).size(), dstbWant.GetShortArrayParam(shortArrayType).size());
EXPECT_EQ(want.GetIntParam(intType, 0), dstbWant.GetIntParam(intType, 0));
EXPECT_EQ(want.GetIntArrayParam(intArrayType).size(), dstbWant.GetIntArrayParam(intArrayType).size());
EXPECT_EQ(want.GetLongParam(longType, 0), dstbWant.GetLongParam(longType, 0));
EXPECT_EQ(want.GetLongArrayParam(longArrayType).size(), dstbWant.GetLongArrayParam(longArrayType).size());
EXPECT_EQ(want.GetFloatParam(floatType, 0), dstbWant.GetFloatParam(floatType, 0));
EXPECT_EQ(want.GetFloatArrayParam(floatArrayType).size(), dstbWant.GetFloatArrayParam(floatArrayType).size());
EXPECT_EQ(want.GetDoubleParam(doubleType, 0), dstbWant.GetDoubleParam(doubleType, 0));
EXPECT_EQ(want.GetDoubleArrayParam(doubleArrayType).size(), dstbWant.GetDoubleArrayParam(doubleArrayType).size());
EXPECT_STREQ(want.GetStringParam(stringType).c_str(), dstbWant.GetStringParam(stringType).c_str());
EXPECT_EQ(want.GetDoubleArrayParam(doubleArrayType).size(), dstbWant.GetDoubleArrayParam(doubleArrayType).size());
EXPECT_EQ(want.GetStringArrayParam(stringArrayType).size(), dstbWant.GetStringArrayParam(stringArrayType).size());
}
/**
* @tc.number: DistributedScheduleWant_Action_0100
* @tc.number: DistributedSchedule_DistributedWant_Convert_0101
* @tc.name: distributedwant
* @tc.desc: Verifying successful conversion of want to distributedwant.
*/
HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_0101, Function | MediumTest | Level3)
{
Want want;
std::vector<bool> bv;
bv.emplace_back(true);
bv.emplace_back(false);
want.SetParam(boolArrayType, bv);
std::vector<byte> byv;
byv.emplace_back(2);
byv.emplace_back(3);
want.SetParam(byteArrayType, byv);
std::vector<zchar> chv;
chv.emplace_back('\n');
chv.emplace_back('p');
chv.emplace_back('i');
want.SetParam(charArrayType, chv);
std::vector<short> shv;
shv.emplace_back(111);
shv.emplace_back(222);
shv.emplace_back(333);
want.SetParam(shortArrayType, shv);
std::vector<int> inv;
inv.emplace_back(1111);
inv.emplace_back(2222);
inv.emplace_back(3333);
inv.emplace_back(4444);
want.SetParam(intArrayType, inv);
std::vector<long> lgv;
lgv.emplace_back(1111);
lgv.emplace_back(2222);
lgv.emplace_back(3333);
lgv.emplace_back(4444);
want.SetParam(longArrayType, lgv);
std::vector<float> ftv;
ftv.emplace_back(1111.1);
ftv.emplace_back(2222.2);
ftv.emplace_back(3333.3);
ftv.emplace_back(4444.4);
want.SetParam(floatArrayType, ftv);
DistributedWant dstbWant(want);
EXPECT_EQ(want.GetBoolArrayParam(boolArrayType).size(), dstbWant.GetBoolArrayParam(boolArrayType).size());
EXPECT_EQ(want.GetByteArrayParam(byteArrayType).size(), dstbWant.GetByteArrayParam(byteArrayType).size());
EXPECT_EQ(want.GetCharArrayParam(charArrayType).size(), dstbWant.GetCharArrayParam(charArrayType).size());
EXPECT_EQ(want.GetShortArrayParam(shortArrayType).size(), dstbWant.GetShortArrayParam(shortArrayType).size());
EXPECT_EQ(want.GetIntArrayParam(intArrayType).size(), dstbWant.GetIntArrayParam(intArrayType).size());
EXPECT_EQ(want.GetLongArrayParam(longArrayType).size(), dstbWant.GetLongArrayParam(longArrayType).size());
EXPECT_EQ(want.GetFloatArrayParam(floatArrayType).size(), dstbWant.GetFloatArrayParam(floatArrayType).size());
}
/**
* @tc.number: DistributedSchedule_DistributedWant_Convert_0200
* @tc.name: ToWant
* @tc.desc: Verifying successful conversion of distributedwant to want.
*/
HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_0200, Function | MediumTest | Level3)
HWTEST_F(DistributedWantBaseTest, DistributedSchedule_Distributedwant_Convert_0200, Function | MediumTest | Level3)
{
std::shared_ptr<DistributedWant> dwant = std::make_shared<DistributedWant>();
std::string description = "liuuy";
@ -252,62 +271,26 @@ HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_02
dwant->SetAction("Action");
dwant->AddEntity("Entity1");
dwant->SetParam(boolType, true);
std::vector<bool> bv;
bv.emplace_back(true);
bv.emplace_back(false);
dwant->SetParam(boolArrayType, bv);
dwant->SetParam(byteType, 1);
std::vector<byte> byv;
byv.emplace_back(2);
byv.emplace_back(3);
dwant->SetParam(byteArrayType, byv);
dwant->SetParam(charType, 6);
std::vector<zchar> chv;
chv.emplace_back('\n');
chv.emplace_back('p');
chv.emplace_back('i');
dwant->SetParam(charArrayType, chv);
dwant->SetParam(shortType, 444);
std::vector<short> shv;
shv.emplace_back(111);
shv.emplace_back(222);
shv.emplace_back(333);
dwant->SetParam(shortArrayType, shv);
dwant->SetParam(intType, 1111);
std::vector<int> inv;
inv.emplace_back(1111);
inv.emplace_back(2222);
inv.emplace_back(3333);
inv.emplace_back(4444);
dwant->SetParam(intArrayType, inv);
dwant->SetParam(longType, 12345);
std::vector<long> lgv;
lgv.emplace_back(1111);
lgv.emplace_back(2222);
lgv.emplace_back(3333);
lgv.emplace_back(4444);
dwant->SetParam(longArrayType, lgv);
dwant->SetParam(floatType, 1.1);
std::vector<float> ftv;
ftv.emplace_back(1111.1);
ftv.emplace_back(2222.2);
ftv.emplace_back(3333.3);
ftv.emplace_back(4444.4);
dwant->SetParam(floatArrayType, ftv);
dwant->SetParam(doubleType, 1.11);
dwant->SetParam(stringType, std::string("string..."));
std::vector<double> dbv;
dbv.emplace_back(1111.11);
dbv.emplace_back(2222.22);
dbv.emplace_back(3333.33);
dbv.emplace_back(4444.44);
dwant->SetParam(doubleArrayType, dbv);
dwant->SetParam(stringType, std::string("string..."));
std::vector<std::string> strv;
strv.emplace_back("1111.11");
strv.emplace_back("2222.22");
dwant->SetParam(stringArrayType, strv);
std::shared_ptr<Want> want = dwant->ToWant();
EXPECT_STREQ(want->GetAction().c_str(), dwant->GetAction().c_str());
EXPECT_STREQ(want->GetType().c_str(), dwant->GetType().c_str());
EXPECT_STREQ(want->GetElement().GetDeviceID().c_str(), dwant->GetElement().GetDeviceID().c_str());
EXPECT_STREQ(want->GetElement().GetBundleName().c_str(), dwant->GetElement().GetBundleName().c_str());
EXPECT_STREQ(want->GetElement().GetAbilityName().c_str(), dwant->GetElement().GetAbilityName().c_str());
@ -316,25 +299,72 @@ HWTEST_F(DistributedWantBaseTest, DistributedSchedule_DistributedWant_Convert_02
EXPECT_STREQ(want->GetAction().c_str(), dwant->GetAction().c_str());
EXPECT_EQ(want->GetEntities().size(), dwant->GetEntities().size());
EXPECT_EQ(want->GetBoolParam(boolType, false), dwant->GetBoolParam(boolType, true));
EXPECT_EQ(want->GetBoolArrayParam(boolArrayType).size(), dwant->GetBoolArrayParam(boolArrayType).size());
EXPECT_EQ(want->GetByteParam(byteType, 0), dwant->GetByteParam(byteType, 0));
EXPECT_EQ(want->GetByteArrayParam(byteArrayType).size(), dwant->GetByteArrayParam(byteArrayType).size());
EXPECT_EQ(want->GetCharParam(charType, 0), dwant->GetCharParam(charType, 0));
EXPECT_EQ(want->GetCharArrayParam(charArrayType).size(), dwant->GetCharArrayParam(charArrayType).size());
EXPECT_EQ(want->GetShortParam(shortType, 0), dwant->GetShortParam(shortType, 0));
EXPECT_EQ(want->GetShortArrayParam(shortArrayType).size(), dwant->GetShortArrayParam(shortArrayType).size());
EXPECT_EQ(want->GetIntParam(intType, 0), dwant->GetIntParam(intType, 0));
EXPECT_EQ(want->GetIntArrayParam(intArrayType).size(), dwant->GetIntArrayParam(intArrayType).size());
EXPECT_EQ(want->GetLongParam(longType, 0), dwant->GetLongParam(longType, 0));
EXPECT_EQ(want->GetLongArrayParam(longArrayType).size(), dwant->GetLongArrayParam(longArrayType).size());
EXPECT_EQ(want->GetFloatParam(floatType, 0), dwant->GetFloatParam(floatType, 0));
EXPECT_EQ(want->GetFloatArrayParam(floatArrayType).size(), dwant->GetFloatArrayParam(floatArrayType).size());
EXPECT_EQ(want->GetDoubleParam(doubleType, 0), dwant->GetDoubleParam(doubleType, 0));
EXPECT_EQ(want->GetDoubleArrayParam(doubleArrayType).size(), dwant->GetDoubleArrayParam(doubleArrayType).size());
EXPECT_STREQ(want->GetStringParam(stringType).c_str(), dwant->GetStringParam(stringType).c_str());
EXPECT_EQ(want->GetDoubleArrayParam(doubleArrayType).size(), dwant->GetDoubleArrayParam(doubleArrayType).size());
EXPECT_EQ(want->GetStringArrayParam(stringArrayType).size(), dwant->GetStringArrayParam(stringArrayType).size());
}
/**
* @tc.number: DistributedSchedule_DistributedWant_Convert_0201
* @tc.name: ToWant
* @tc.desc: Verifying successful conversion of distributedwant to want.
*/
HWTEST_F(DistributedWantBaseTest, DistributedSchedule_Distributedwant_Convert_0201, Function | MediumTest | Level3)
{
std::shared_ptr<DistributedWant> dwant = std::make_shared<DistributedWant>();
std::vector<bool> bv;
bv.emplace_back(true);
bv.emplace_back(false);
dwant->SetParam(boolArrayType, bv);
std::vector<byte> byv;
byv.emplace_back(2);
byv.emplace_back(3);
dwant->SetParam(byteArrayType, byv);
std::vector<zchar> chv;
chv.emplace_back('\n');
chv.emplace_back('p');
chv.emplace_back('i');
dwant->SetParam(charArrayType, chv);
std::vector<short> shv;
shv.emplace_back(111);
shv.emplace_back(222);
shv.emplace_back(333);
dwant->SetParam(shortArrayType, shv);
std::vector<int> inv;
inv.emplace_back(1111);
inv.emplace_back(2222);
inv.emplace_back(3333);
inv.emplace_back(4444);
dwant->SetParam(intArrayType, inv);
std::vector<long> lgv;
lgv.emplace_back(1111);
lgv.emplace_back(2222);
lgv.emplace_back(3333);
lgv.emplace_back(4444);
dwant->SetParam(longArrayType, lgv);
std::vector<float> ftv;
ftv.emplace_back(1111.1);
ftv.emplace_back(2222.2);
ftv.emplace_back(3333.3);
ftv.emplace_back(4444.4);
dwant->SetParam(floatArrayType, ftv);
std::shared_ptr<Want> want = dwant->ToWant();
EXPECT_EQ(want->GetBoolArrayParam(boolArrayType).size(), dwant->GetBoolArrayParam(boolArrayType).size());
EXPECT_EQ(want->GetByteArrayParam(byteArrayType).size(), dwant->GetByteArrayParam(byteArrayType).size());
EXPECT_EQ(want->GetCharArrayParam(charArrayType).size(), dwant->GetCharArrayParam(charArrayType).size());
EXPECT_EQ(want->GetShortArrayParam(shortArrayType).size(), dwant->GetShortArrayParam(shortArrayType).size());
EXPECT_EQ(want->GetIntArrayParam(intArrayType).size(), dwant->GetIntArrayParam(intArrayType).size());
EXPECT_EQ(want->GetLongArrayParam(longArrayType).size(), dwant->GetLongArrayParam(longArrayType).size());
EXPECT_EQ(want->GetFloatArrayParam(floatArrayType).size(), dwant->GetFloatArrayParam(floatArrayType).size());
}
/**
* @tc.number: DistributedScheduleWant_Type_0100
* @tc.name: SetType/GetType
@ -389,9 +419,6 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0100, Funct
return;
}
WantIn_->SetAction("12345");
WantIn_->SetFlags(123);
WantIn_->SetAction("12345");
WantIn_->SetFlags(123);
WantIn_->AddEntity("12345");
@ -406,14 +433,11 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0100, Funct
element.SetDeviceID("12345");
WantIn_->SetElement(element);
WantIn_->SetType("12345");
size_t pos1;
size_t pos2;
bool result = false;
Parcel in;
pos1 = in.GetWritePosition();
result = WantIn_->Marshalling(in);
pos2 = in.GetWritePosition();
size_t pos1 = in.GetWritePosition();
bool result = WantIn_->Marshalling(in);
size_t pos2 = in.GetWritePosition();
EXPECT_EQ(result, true);
GTEST_LOG_(INFO) << " Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
@ -590,14 +614,10 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0400, Funct
WantIn_->SetElement(element);
WantIn_->SetType("12345");
size_t pos1;
size_t pos2;
bool result = false;
Parcel in;
pos1 = in.GetWritePosition();
result = WantIn_->Marshalling(in);
pos2 = in.GetWritePosition();
size_t pos1 = in.GetWritePosition();
bool result = WantIn_->Marshalling(in);
size_t pos2 = in.GetWritePosition();
EXPECT_EQ(result, true);
GTEST_LOG_(INFO) << "Marshalling: pos1: " << pos1 << ", pos2: " << pos2 << ", result: " << result;
@ -633,14 +653,12 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0400, Funct
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0500, Function | MediumTest | Level3)
{
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_005 start";
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_0500 start";
std::shared_ptr<DistributedWant> WantIn_ = std::make_shared<DistributedWant>();
if (WantIn_ == nullptr) {
return;
}
WantIn_->SetAction("system.test.action");
WantIn_->SetFlags(64);
WantIn_->AddEntity("system.test.entity");
OHOS::AppExecFwk::ElementName element;
@ -658,54 +676,12 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0500, Funct
wantParams.SetParam(keyStr, String::Box(valueString));
WantIn_->SetParams(wantParams);
// want SetParam arraydata test
std::vector<bool> boolArrayValue = {true, false, true};
WantIn_->SetParam(std::string("bool_arraykey"), boolArrayValue);
std::vector<byte> byteArrayValue = {'?', 'a', '\\'};
WantIn_->SetParam(std::string("byte_arraykey"), byteArrayValue);
std::vector<zchar> charArrayValue = {U'e', U'l', U'l', U'o'};
WantIn_->SetParam(std::string("char_arraykey"), charArrayValue);
std::vector<short> shortArrayValue = {-1, 0, 1};
WantIn_->SetParam(std::string("short_arraykey"), shortArrayValue);
std::vector<int> intArrayValue = {-10, 0, 10};
WantIn_->SetParam(std::string("int_arraykey"), intArrayValue);
std::vector<long> longArrayValue = {-100, 0, 100};
WantIn_->SetParam(std::string("long_arraykey"), longArrayValue);
std::vector<float> floatArrayValue = {-100.1, 0.1, 100.1};
WantIn_->SetParam(std::string("float_arraykey"), floatArrayValue);
std::vector<double> doubleArrayValue = {-1000.1, 0.1, 1000.1};
WantIn_->SetParam(std::string("double_arraykey"), doubleArrayValue);
std::vector<std::string> stringArrayValue = {"stringtest1", "string@test2", "string@!#test2"};
WantIn_->SetParam(std::string("string_arraykey"), stringArrayValue);
DistributedWant wantCopy(*WantIn_);
std::vector<std::string> teststringArrayValue1 = WantIn_->GetStringArrayParam(std::string("string_arraykey"));
std::vector<std::string> teststringArrayValue2 = wantCopy.GetStringArrayParam(std::string("string_arraykey"));
bool copyarraycompare = CompareArrayData<std::string>(teststringArrayValue1, teststringArrayValue1);
EXPECT_EQ(copyarraycompare, true);
std::string str = (copyarraycompare == true) ? "true" : "false";
GTEST_LOG_(INFO) << "copyarraycompare=" << str.c_str();
Parcel in;
bool result = false;
result = WantIn_->Marshalling(in);
EXPECT_EQ(result, true);
std::shared_ptr<DistributedWant> WantOut_(DistributedWant::Unmarshalling(in));
if (WantOut_ != nullptr) {
GTEST_LOG_(INFO) << "WantOut_->GetAction().c_str(): " << WantOut_->GetAction().c_str();
EXPECT_STREQ(WantOut_->GetAction().c_str(), std::string("system.test.action").c_str());
int flags = WantOut_->GetFlags();
GTEST_LOG_(INFO) << "WantOut_->GetFlags(): " << flags;
EXPECT_EQ(static_cast<int>(flags), 64);
bool hasentity = WantOut_->HasEntity("system.test.entity");
GTEST_LOG_(INFO) << "WantOut_->HasEntity(system.test.entity)" << hasentity;
@ -732,7 +708,54 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0500, Funct
std::string param_content = WantOut_->GetStringParam(keyStr);
GTEST_LOG_(INFO) << "WantOut_->GetStringParam(keyStr): " << param_content.c_str();
// want SetParam arraydata test
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_005 end";
}
}
/**
* @tc.number: DistributedScheduleWant_Parcelable_0501
* @tc.name: Marshalling/Unmarshalling
* @tc.desc: marshalling Want, and then check result.
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0501, Function | MediumTest | Level3)
{
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_0501 start";
std::shared_ptr<DistributedWant> WantIn_ = std::make_shared<DistributedWant>();
if (WantIn_ == nullptr) {
return;
}
WantIn_->SetAction("system.test.action");
std::vector<bool> boolArrayValue = {true, false, true};
WantIn_->SetParam(std::string("bool_arraykey"), boolArrayValue);
std::vector<byte> byteArrayValue = {'?', 'a', '\\'};
WantIn_->SetParam(std::string("byte_arraykey"), byteArrayValue);
std::vector<zchar> charArrayValue = {U'e', U'l', U'l', U'o'};
WantIn_->SetParam(std::string("char_arraykey"), charArrayValue);
std::vector<std::string> stringArrayValue = {"stringtest1", "string@test2", "string@!#test2"};
WantIn_->SetParam(std::string("string_arraykey"), stringArrayValue);
DistributedWant wantCopy(*WantIn_);
std::vector<std::string> teststringArrayValue1 = WantIn_->GetStringArrayParam(std::string("string_arraykey"));
std::vector<std::string> teststringArrayValue2 = wantCopy.GetStringArrayParam(std::string("string_arraykey"));
bool copyarraycompare = CompareArrayData<std::string>(teststringArrayValue1, teststringArrayValue1);
EXPECT_EQ(copyarraycompare, true);
std::string str = (copyarraycompare == true) ? "true" : "false";
GTEST_LOG_(INFO) << "copyarraycompare=" << str.c_str();
Parcel in;
bool result = false;
result = WantIn_->Marshalling(in);
EXPECT_EQ(result, true);
std::shared_ptr<DistributedWant> WantOut_(DistributedWant::Unmarshalling(in));
if (WantOut_ != nullptr) {
GTEST_LOG_(INFO) << "WantOut_->GetAction().c_str(): " << WantOut_->GetAction().c_str();
EXPECT_STREQ(WantOut_->GetAction().c_str(), std::string("system.test.action").c_str());
std::vector<bool> retboolArray;
retboolArray = WantOut_->GetBoolArrayParam(std::string("bool_arraykey"));
@ -749,9 +772,56 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0500, Funct
arraycompare = CompareArrayData<zchar>(retcharArrayValue, charArrayValue);
EXPECT_EQ(arraycompare, true);
std::vector<std::string> retstringArrayValue;
retstringArrayValue = WantOut_->GetStringArrayParam(std::string("string_arraykey"));
arraycompare = CompareArrayData<std::string>(retstringArrayValue, stringArrayValue);
EXPECT_EQ(arraycompare, true);
}
}
/**
* @tc.number: DistributedScheduleWant_Parcelable_0502
* @tc.name: Marshalling/Unmarshalling
* @tc.desc: marshalling Want, and then check result.
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0502, Function | MediumTest | Level3)
{
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_0502 start";
std::shared_ptr<DistributedWant> WantIn_ = std::make_shared<DistributedWant>();
if (WantIn_ == nullptr) {
return;
}
WantIn_->SetFlags(64);
std::vector<short> shortArrayValue = {-1, 0, 1};
WantIn_->SetParam(std::string("short_arraykey"), shortArrayValue);
std::vector<int> intArrayValue = {-10, 0, 10};
WantIn_->SetParam(std::string("int_arraykey"), intArrayValue);
std::vector<long> longArrayValue = {-100, 0, 100};
WantIn_->SetParam(std::string("long_arraykey"), longArrayValue);
std::vector<float> floatArrayValue = {-100.1, 0.1, 100.1};
WantIn_->SetParam(std::string("float_arraykey"), floatArrayValue);
std::vector<double> doubleArrayValue = {-1000.1, 0.1, 1000.1};
WantIn_->SetParam(std::string("double_arraykey"), doubleArrayValue);
Parcel in;
bool result = false;
result = WantIn_->Marshalling(in);
EXPECT_EQ(result, true);
std::shared_ptr<DistributedWant> WantOut_(DistributedWant::Unmarshalling(in));
if (WantOut_ != nullptr) {
int flags = WantOut_->GetFlags();
GTEST_LOG_(INFO) << "WantOut_->GetFlags(): " << flags;
EXPECT_EQ(static_cast<int>(flags), 64);
std::vector<short> retshortArrayValue;
retshortArrayValue = WantOut_->GetShortArrayParam(std::string("short_arraykey"));
arraycompare = CompareArrayData<short>(retshortArrayValue, shortArrayValue);
bool arraycompare = CompareArrayData<short>(retshortArrayValue, shortArrayValue);
EXPECT_EQ(arraycompare, true);
std::vector<int> retintArrayValue;
@ -773,13 +843,6 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_Parcelable_0500, Funct
retdoubleArrayValue = WantOut_->GetDoubleArrayParam(std::string("double_arraykey"));
arraycompare = CompareArrayData<double>(retdoubleArrayValue, doubleArrayValue);
EXPECT_EQ(arraycompare, true);
std::vector<std::string> retstringArrayValue;
retstringArrayValue = WantOut_->GetStringArrayParam(std::string("string_arraykey"));
arraycompare = CompareArrayData<std::string>(retstringArrayValue, stringArrayValue);
EXPECT_EQ(arraycompare, true);
GTEST_LOG_(INFO) << "DistributedScheduleWant_Parcelable_005 end";
}
}
@ -1201,6 +1264,99 @@ void DistributedWantBaseTest::AddStringParams(DistributedWant& want,
}
}
void DistributedWantBaseTest::TestStringForParseUri(std::string uri,
std::string keyString, std::size_t &length, std::string valueStringOrigin)
{
std::size_t head = length;
std::string search = String::SIGNATURE + std::string(".") + keyString + std::string("=");
std::size_t result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
std::size_t pos = result + search.length();
std::size_t delims = uri.find(";", pos);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
std::string valueStringNew = String::Unbox(String::Parse(substring));
EXPECT_EQ(valueStringNew, valueStringOrigin);
length += substring.length() + 1;
}
}
}
void DistributedWantBaseTest::TestFloatForParseUri(std::string uri,
std::string keyFloat, std::size_t &length, float valueFloatOrigin)
{
std::size_t head = length;
std::string search = Float::SIGNATURE + std::string(".") + keyFloat + std::string("=");
std::size_t result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
std::size_t pos = result + search.length();
std::size_t delims = uri.find(";", pos);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
float valueFloatNew = Float::Unbox(Float::Parse(substring));
EXPECT_EQ(valueFloatNew, valueFloatOrigin);
length += substring.length() + 1;
}
}
}
void DistributedWantBaseTest::TestFloatArrayForParseUri(std::string uri,
std::string keyFloatArray, std::size_t &length, std::vector<float> valueFloatArrayOrigin)
{
std::size_t head = length;
std::string search = Array::SIGNATURE + std::string(".") + keyFloatArray + std::string("=");
std::size_t result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
std::size_t pos = result + search.length();
std::size_t delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
sptr<IArray> array = Array::Parse(substring);
std::vector<float> valueFloatArrayNew;
auto func = [&valueFloatArrayNew](
IInterface *object) { valueFloatArrayNew.push_back(Float::Unbox(IFloat::Query(object))); };
Array::ForEach(array, func);
EXPECT_EQ(valueFloatArrayNew, valueFloatArrayOrigin);
length += substring.length() + 1;
}
}
}
void DistributedWantBaseTest::TestStringArrayForParseUri(std::string uri,
std::string keyStringArray, std::size_t &length, std::vector<std::string> valueStringArrayOrigin)
{
std::size_t head = length;
std::string search = Array::SIGNATURE + std::string(".") + keyStringArray + std::string("=");
std::size_t result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
std::size_t pos = result + search.length();
std::size_t delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
sptr<IArray> array = Array::Parse(substring);
std::vector<std::string> valueStringArrayNew;
auto func = [&valueStringArrayNew](IInterface *object) {
valueStringArrayNew.push_back(String::Unbox(IString::Query(object)));
};
Array::ForEach(array, func);
EXPECT_EQ(valueStringArrayNew, valueStringArrayOrigin);
length += substring.length() + 1;
}
}
}
/**
* @tc.number: DistributedScheduleWant_Parcelable_0600
* @tc.name: parcelable
@ -1432,12 +1588,8 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0200, F
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0300, Function | MediumTest | Level3)
{
std::string search;
std::string substring;
std::size_t pos = 0;
std::size_t length = 0;
std::size_t result = 0;
std::size_t delims = 0;
std::size_t head = 0;
Want wantOrigin;
std::string keyFloat = "keyFloat";
@ -1446,29 +1598,14 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0300, F
std::string uri = wantOrigin.ToUri();
search = DistributedWantBaseTest::URI_STRING_HEAD;
result = uri.find(search, pos);
std::string search = DistributedWantBaseTest::URI_STRING_HEAD;
std::size_t result = uri.find(search, pos);
EXPECT_EQ(result, pos);
if (result != std::string::npos) {
head = result + search.length();
}
length += head;
search = Float::SIGNATURE + std::string(".") + keyFloat + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", pos);
if (delims != std::string::npos) {
substring = uri.substr(pos, delims - pos);
float valueFloatNew = Float::Unbox(Float::Parse(substring));
EXPECT_EQ(valueFloatNew, valueFloatOrigin);
length += substring.length() + 1;
}
}
TestFloatForParseUri(uri, keyFloat, length, valueFloatOrigin);
search = DistributedWantBaseTest::URI_STRING_END;
result = uri.find(search);
@ -1499,12 +1636,8 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0300, F
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0400, Function | MediumTest | Level3)
{
std::string search;
std::string substring;
std::size_t pos = 0;
std::size_t length = 0;
std::size_t result = 0;
std::size_t delims = 0;
std::size_t head = 0;
DistributedWant wantOrigin;
std::string keyFloat = "keyFloat";
@ -1516,46 +1649,16 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0400, F
std::string uri = wantOrigin.ToUri();
search = DistributedWantBaseTest::URI_STRING_HEAD;
result = uri.find(search, pos);
std::string search = DistributedWantBaseTest::URI_STRING_HEAD;
std::size_t result = uri.find(search, pos);
EXPECT_NE(result, std::string::npos);
EXPECT_EQ(result, pos);
if (result != std::string::npos) {
head = result + search.length();
}
length += head;
search = Float::SIGNATURE + std::string(".") + keyFloat + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", pos);
if (delims != std::string::npos) {
substring = uri.substr(pos, delims - pos);
float valueFloatNew = Float::Unbox(Float::Parse(substring));
EXPECT_EQ(valueFloatNew, valueFloatOrigin);
length += substring.length() + 1;
}
}
search = String::SIGNATURE + std::string(".") + keyString + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
std::string valueStringNew = String::Unbox(String::Parse(substring));
EXPECT_EQ(valueStringNew, valueStringOrigin);
length += substring.length() + 1;
}
}
TestFloatForParseUri(uri, keyFloat, length, valueFloatOrigin);
TestStringForParseUri(uri, keyString, length, valueStringOrigin);
search = DistributedWantBaseTest::URI_STRING_END;
result = uri.find(search);
@ -1614,26 +1717,7 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0500, F
}
length += head;
search = Array::SIGNATURE + std::string(".") + keyFloatArray + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
sptr<IArray> array = Array::Parse(substring);
std::vector<float> valueFloatArrayNew;
auto func = [&valueFloatArrayNew](
IInterface *object) { valueFloatArrayNew.push_back(Float::Unbox(IFloat::Query(object))); };
Array::ForEach(array, func);
EXPECT_EQ(valueFloatArrayNew, valueFloatArrayOrigin);
length += substring.length() + 1;
}
}
TestFloatArrayForParseUri(uri, keyFloatArray, length, valueFloatArrayOrigin);
search = DistributedWantBaseTest::URI_STRING_END;
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
@ -1663,12 +1747,8 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0500, F
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0600, Function | MediumTest | Level3)
{
std::string search;
std::string substring;
std::size_t pos = 0;
std::size_t length = 0;
std::size_t result = 0;
std::size_t delims = 0;
std::size_t head = 0;
DistributedWant wantOrigin;
std::string keyFloatArray = "keyFloatArray";
@ -1680,8 +1760,8 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0600, F
std::string uri = wantOrigin.ToUri();
search = DistributedWantBaseTest::URI_STRING_HEAD;
result = uri.find(search, pos);
std::string search = DistributedWantBaseTest::URI_STRING_HEAD;
std::size_t result = uri.find(search, pos);
EXPECT_NE(result, std::string::npos);
EXPECT_EQ(result, pos);
if (result != std::string::npos) {
@ -1689,46 +1769,8 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_0600, F
}
length += head;
search = Array::SIGNATURE + std::string(".") + keyFloatArray + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
sptr<IArray> array = Array::Parse(substring);
std::vector<float> valueFloatArrayNew;
auto func = [&valueFloatArrayNew](
IInterface *object) { valueFloatArrayNew.push_back(Float::Unbox(IFloat::Query(object))); };
Array::ForEach(array, func);
EXPECT_EQ(valueFloatArrayNew, valueFloatArrayOrigin);
length += substring.length() + 1;
}
}
search = Array::SIGNATURE + std::string(".") + keyStringArray + std::string("=");
result = uri.find(search);
EXPECT_NE(result, std::string::npos);
EXPECT_GE(result, head);
length += search.length();
if (result != std::string::npos) {
pos = result + search.length();
delims = uri.find(";", result);
if (delims != std::string::npos) {
std::string substring = uri.substr(pos, delims - pos);
sptr<IArray> array = Array::Parse(substring);
std::vector<std::string> valueStringArrayNew;
auto func = [&valueStringArrayNew](IInterface *object) {
valueStringArrayNew.push_back(String::Unbox(IString::Query(object)));
};
Array::ForEach(array, func);
EXPECT_EQ(valueStringArrayNew, valueStringArrayOrigin);
length += substring.length() + 1;
}
}
TestFloatArrayForParseUri(uri, keyFloatArray, length, valueFloatArrayOrigin);
TestStringArrayForParseUri(uri, keyStringArray, length, valueStringArrayOrigin);
search = DistributedWantBaseTest::URI_STRING_END;
result = uri.find(search);
@ -1972,9 +2014,17 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_1400, F
delete want;
want = nullptr;
}
}
uri = "#Intent;param;end";
want = DistributedWant::ParseUri(uri);
/**
* @tc.number: DistributedScheduleWant_ParseUri_ToUri_1401
* @tc.name: ParseUri and ToUri
* @tc.desc: Verify the function when no '=' or only has a '='.
*/
HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_1401, Function | MediumTest | Level3)
{
std::string uri = "#Intent;param;end"; // test string
DistributedWant* want = DistributedWant::ParseUri(uri);
EXPECT_EQ(want, nullptr);
if (want != nullptr) {
delete want;
@ -1982,7 +2032,7 @@ HWTEST_F(DistributedWantBaseTest, DistributedScheduleWant_ParseUri_ToUri_1400, F
}
uri = "#Intent;=;end";
want = DistributedWant::ParseUri(uri);
want = DistributedWant::ParseUri(uri);
EXPECT_NE(want, nullptr);
if (want != nullptr) {
delete want;