* Copyright (c) 2020 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 "service_impl.h"
#include <string.h>
#include "memory_adapter.h"
#include "thread_adapter.h"
#include "time_adapter.h"
#include "feature_impl.h"
#include "service_registry.h"
static const char *GetFeatureName(const FeatureImpl *featureImpl);
ServiceImpl *SAMGR_CreateServiceImpl(Service *service, uint8 step)
{
ServiceImpl *impl = (ServiceImpl *)SAMGR_Malloc(sizeof(ServiceImpl));
if (impl == NULL) {
return NULL;
}
impl->service = service;
impl->defaultApi = NULL;
impl->taskPool = NULL;
impl->features = VECTOR_Make((VECTOR_Key)GetFeatureName, (VECTOR_Compare)strcmp);
impl->serviceId = INVALID_INDEX;
impl->inited = SVC_INIT;
impl->ops.abnormal = 0;
impl->ops.messages = 0;
impl->ops.step = step;
impl->ops.timestamp = (uint32)SAMGR_GetProcessTime();
return impl;
}
int16 DEFAULT_AddFeature(ServiceImpl *serviceImpl, Feature *feature)
{
if (serviceImpl == NULL || feature == NULL) {
return INVALID_INDEX;
}
if (VECTOR_Num(&(serviceImpl->features)) >= MAX_FEATURE_NUM) {
return INVALID_INDEX;
}
FeatureImpl *impl = FEATURE_CreateInstance(feature);
if (impl == NULL) {
return INVALID_INDEX;
}
int16 featureId = VECTOR_Add(&(serviceImpl->features), impl);
if (featureId == INVALID_INDEX) {
SAMGR_Free(impl);
}
return featureId;
}
void DEFAULT_Initialize(ServiceImpl *impl)
{
if (impl == NULL) {
return;
}
Identity id = {impl->serviceId, INVALID_INDEX, (impl->taskPool != NULL) ? impl->taskPool->queueId : NULL};
impl->service->Initialize(impl->service, id);
const char *serviceName = impl->service->GetName(impl->service);
SAMGR_RegisterServiceApi(serviceName, NULL, &id, impl->defaultApi);
int16 size = VECTOR_Size(&impl->features);
int16 i;
for (i = 0; i < size; ++i) {
FeatureImpl *feature = (FeatureImpl *)VECTOR_At(&(impl->features), i);
if (feature == NULL) {
continue;
}
id.featureId = i;
feature->feature->OnInitialize(feature->feature, impl->service, id);
SAMGR_RegisterServiceApi(serviceName, feature->feature->GetName(feature->feature), &id, feature->iUnknown);
}
}
void DEFAULT_MessageHandle(ServiceImpl *serviceImpl, const Identity *identity, Request *msg)
{
if (serviceImpl->serviceId != identity->serviceId) {
return;
}
if (identity->featureId < 0) {
if (serviceImpl->service->MessageHandle != NULL) {
serviceImpl->service->MessageHandle(serviceImpl->service, msg);
}
return;
}
if (VECTOR_Size(&serviceImpl->features) <= identity->featureId) {
return;
}
FeatureImpl *featureImpl = (FeatureImpl *)VECTOR_At(&(serviceImpl->features), identity->featureId);
if (featureImpl == NULL) {
return;
}
featureImpl->feature->OnMessage(featureImpl->feature, msg);
}
void DEFAULT_StopService(ServiceImpl *service)
{
if (service == NULL) {
return;
}
Identity id = {service->serviceId, INVALID_INDEX, (service->taskPool != NULL) ? service->taskPool->queueId : NULL};
int16 size = VECTOR_Size(&service->features);
int16 i;
for (i = 0; i < size; ++i) {
FeatureImpl *featureImpl = (FeatureImpl *)VECTOR_At(&(service->features), i);
if (featureImpl == NULL) {
continue;
}
id.featureId = i;
featureImpl->feature->OnStop(featureImpl->feature, id);
}
service->inited = SVC_INIT;
}
FeatureImpl *DEFAULT_GetFeature(ServiceImpl *serviceImpl, const char *featureName)
{
if (serviceImpl == NULL || featureName == NULL) {
return NULL;
}
short pos = VECTOR_FindByKey(&(serviceImpl->features), (void *)featureName);
return (FeatureImpl *)VECTOR_At(&(serviceImpl->features), pos);
}
Identity DEFAULT_GetFeatureId(ServiceImpl *serviceImpl, const char *feature)
{
Identity identity = {INVALID_INDEX, INVALID_INDEX, NULL};
if (serviceImpl == NULL) {
return identity;
}
identity.serviceId = serviceImpl->serviceId;
if (serviceImpl->taskPool != NULL) {
identity.queueId = serviceImpl->taskPool->queueId;
}
int16 pos = VECTOR_FindByKey(&(serviceImpl->features), (void *)feature);
FeatureImpl *featureImpl = (FeatureImpl *)VECTOR_At(&(serviceImpl->features), pos);
if (featureImpl == NULL) {
return identity;
}
identity.featureId = pos;
return identity;
}
Feature *DEFAULT_DeleteFeature(ServiceImpl *serviceImpl, const char *featureName)
{
if (serviceImpl == NULL || featureName == NULL) {
return NULL;
}
int16 pos = VECTOR_FindByKey(&(serviceImpl->features), (void *)featureName);
if (pos < 0 || !SAMGR_IsNoInterface((FeatureImpl *)VECTOR_At(&serviceImpl->features, pos))) {
return NULL;
}
FeatureImpl *featureImpl = (FeatureImpl *)VECTOR_Swap(&(serviceImpl->features), pos, NULL);
if (featureImpl == NULL) {
return NULL;
}
Identity id = {serviceImpl->serviceId, INVALID_INDEX, NULL};
featureImpl->feature->OnStop(featureImpl->feature, id);
Feature *feature = featureImpl->feature;
SAMGR_Free(featureImpl);
return feature;
}
static const char *GetFeatureName(const FeatureImpl *featureImpl)
{
if (featureImpl == NULL) {
return NULL;
}
return featureImpl->feature->GetName(featureImpl->feature);
}
