* 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 "napi_utils.h"
#include "net_manager_constants.h"
#include "netmanager_ext_log.h"
#include "constant.h"
#include "mdns_client.h"
#include "mdns_exec.h"
#include "mdns_instances.h"
#include "hi_app_event_report.h"
namespace OHOS {
namespace NetManagerStandard {
bool MDnsExec::ExecAddLocalService(MDnsAddLocalServiceContext *context)
{
auto hiAppEventReport = std::make_shared<HiAppEventReport>("NetworkKit", "MDnsAddLocalService");
auto ret =
DelayedSingleton<MDnsClient>::GetInstance()->RegisterService(context->GetServiceInfo(), context->GetObserver());
if (ret != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(ret);
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
NETMANAGER_EXT_LOGE("RegisterService error, errorCode: %{public}d", ret);
return false;
}
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
return ret == NETMANAGER_EXT_SUCCESS;
}
bool MDnsExec::ExecRemoveLocalService(MDnsRemoveLocalServiceContext *context)
{
sptr<IRegistrationCallback> callback = context->GetObserver();
auto ret = DelayedSingleton<MDnsClient>::GetInstance()->UnRegisterService(callback);
if (ret != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(ret);
NETMANAGER_EXT_LOGE("UnRegisterService error, errorCode: %{public}d", ret);
return false;
}
return ret == NETMANAGER_EXT_SUCCESS;
}
bool MDnsExec::ExecResolveLocalService(MDnsResolveLocalServiceContext *context)
{
auto ret =
DelayedSingleton<MDnsClient>::GetInstance()->ResolveService(context->GetServiceInfo(), context->GetObserver());
if (ret != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(ret);
NETMANAGER_EXT_LOGE("ResolveService error, errorCode: %{public}d", ret);
return false;
}
sptr<IResolveCallback> callback = context->GetObserver();
MDnsResolveObserver *observer = static_cast<MDnsResolveObserver *>(callback.GetRefPtr());
if (observer == nullptr) {
context->SetErrorCode(NET_MDNS_ERR_UNKNOWN);
return false;
}
std::unique_lock<std::mutex> lk(observer->mutex_);
if (!observer->cv_.wait_for(lk, std::chrono::seconds(SYNC_TIMEOUT), [=]() { return observer->resolved_; })) {
context->SetErrorCode(NET_MDNS_ERR_TIMEOUT);
return false;
}
context->SetServiceInfo(observer->serviceInfo_);
if (observer->retCode_ != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(observer->retCode_);
NETMANAGER_EXT_LOGE("HandleResolveResult error, errorCode: %{public}d", ret);
return false;
}
return observer->retCode_ == NETMANAGER_EXT_SUCCESS;
}
bool MDnsExec::ExecStartSearchingMDNS(MDnsStartSearchingContext *context)
{
auto hiAppEventReport = std::make_shared<HiAppEventReport>("NetworkKit", "MDnsExecStartSearching");
auto discover = context->GetDiscover();
auto ret =
DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(discover.serviceType_, discover.observer_);
if (ret != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(ret);
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
NETMANAGER_EXT_LOGE("StartDiscoverService error, errorCode: %{public}d", ret);
}
MDnsServiceInfo info;
info.type = discover.serviceType_;
auto wObserver = context->GetObserver();
sptr<MDnsDiscoveryObserver> observer = wObserver.promote();
if (observer == nullptr) {
NETMANAGER_EXT_LOGE("ExecStartSearchingMDNS GetObserver nullptr");
return false;
}
observer->EmitStartDiscover(info, ret);
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
return ret == NETMANAGER_EXT_SUCCESS;
}
bool MDnsExec::ExecStopSearchingMDNS(MDnsStopSearchingContext *context)
{
auto hiAppEventReport = std::make_shared<HiAppEventReport>("NetworkKit", "MDnsStopSearching");
auto discover = context->GetDiscover();
auto ret = DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(discover.observer_);
if (ret != NETMANAGER_EXT_SUCCESS) {
context->SetErrorCode(ret);
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
NETMANAGER_EXT_LOGE("StopDiscoverService error, errorCode: %{public}d", ret);
}
MDnsServiceInfo info;
info.type = discover.serviceType_;
auto wObserver = context->GetObserver();
sptr<MDnsDiscoveryObserver> observer = wObserver.promote();
if (observer == nullptr) {
NETMANAGER_EXT_LOGE("ExecStopSearchingMDNS GetObserver nullptr");
return false;
}
observer->EmitStopDiscover(info, ret);
hiAppEventReport->ReportSdkEvent(RESULT_SUCCESS, ret);
return ret == NETMANAGER_EXT_SUCCESS;
}
napi_value CreateAttributeObj(napi_env env, MDnsServiceInfo serviceInfo)
{
TxtRecord attrMap = serviceInfo.GetAttrMap();
auto attrArrSize = attrMap.size();
size_t index = 0;
auto iter = attrMap.begin();
napi_value attrArr = NapiUtils::CreateArray(env, attrArrSize);
for (; iter != attrMap.end(); iter++, index++) {
napi_value attrItem = NapiUtils::CreateObject(env);
NapiUtils::SetStringPropertyUtf8(env, attrItem, SERVICEINFO_ATTR_KEY, iter->first);
auto valArrSize = iter->second.size();
napi_value valArr = NapiUtils::CreateArray(env, valArrSize);
auto setIter = iter->second.begin();
size_t setIndex = 0;
for (; setIter != iter->second.end(); setIter++, setIndex++) {
NapiUtils::SetArrayElement(env, valArr, setIndex, NapiUtils::CreateUint32(env, *setIter));
}
NapiUtils::SetNamedProperty(env, attrItem, SERVICEINFO_ATTR_VALUE, valArr);
NapiUtils::SetArrayElement(env, attrArr, index, attrItem);
}
return attrArr;
}
template <class T> napi_value CreateCallbackParam(T *context)
{
napi_env env = context->GetEnv();
MDnsServiceInfo serviceInfo = context->GetServiceInfo();
NETMANAGER_EXT_LOGI("CreateCallbackParam [%{public}s][%{public}d]",
serviceInfo.type.c_str(), serviceInfo.port);
napi_value object = NapiUtils::CreateObject(env);
NapiUtils::SetStringPropertyUtf8(env, object, SERVICEINFO_TYPE, serviceInfo.type);
NapiUtils::SetStringPropertyUtf8(env, object, SERVICEINFO_NAME, serviceInfo.name);
NapiUtils::SetInt32Property(env, object, SERVICEINFO_PORT, serviceInfo.port);
napi_value eleObj = NapiUtils::CreateObject(env);
NapiUtils::SetStringPropertyUtf8(env, eleObj, SERVICEINFO_ADDRESS, serviceInfo.addr);
NapiUtils::SetInt32Property(env, eleObj, SERVICEINFO_PORT, serviceInfo.port);
int32_t family = serviceInfo.family == MDnsServiceInfo::IPV6 ? 0 : 1;
NapiUtils::SetInt32Property(env, eleObj, SERVICEINFO_FAMILY, family);
napi_value attrArrObj = CreateAttributeObj(env, serviceInfo);
NapiUtils::SetNamedProperty(env, object, SERVICEINFO_HOST, eleObj);
NapiUtils::SetNamedProperty(env, object, SERVICEINFO_ATTR, attrArrObj);
return object;
}
napi_value MDnsExec::AddLocalServiceCallback(MDnsAddLocalServiceContext *context)
{
return CreateCallbackParam<MDnsAddLocalServiceContext>(context);
}
napi_value MDnsExec::RemoveLocalServiceCallback(MDnsRemoveLocalServiceContext *context)
{
return CreateCallbackParam<MDnsRemoveLocalServiceContext>(context);
}
napi_value MDnsExec::ResolveLocalServiceCallback(MDnsResolveLocalServiceContext *context)
{
return CreateCallbackParam<MDnsResolveLocalServiceContext>(context);
}
napi_value MDnsExec::StartSearchingMDNSCallback(MDnsStartSearchingContext *context)
{
return NapiUtils::GetUndefined(context->GetEnv());
}
napi_value MDnsExec::StopSearchingMDNSCallback(MDnsStopSearchingContext *context)
{
return NapiUtils::GetUndefined(context->GetEnv());
}
}
}
