openharmony/ability_ability_runtime
1
0
Fork 0
mirror of https://gitee.com/openharmony/ability_ability_runtime synced 2024-10-07 16:33:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

modify hilog for Ability and AppKitNative

Browse Source 
Signed-off-by: 黄师伟 <huangshiwei4@huawei.com>
This commit is contained in:
黄师伟 2022-07-29 15:50:04 +08:00
parent 3b15b70826
commit 4378ff9e13
8 changed files with 191 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
frameworks/native/ability/native/ability_context.cpp
View File

@ -110,7 +110,6 @@ std::string AbilityContext::GetCallingBundle()
std::shared_ptr<ElementName> AbilityContext::GetElementName()
{
HILOG_INFO("%{public}s begin.", __func__);
std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
if (info == nullptr) {
HILOG_ERROR("AbilityContext::GetElementName info == nullptr");
@ -126,13 +125,12 @@ std::shared_ptr<ElementName> AbilityContext::GetElementName()
elementName->SetBundleName(info->bundleName);
elementName->SetDeviceID(info->deviceId);
elementName->SetModuleName(info->moduleName);
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
return elementName;
}
std::shared_ptr<ElementName> AbilityContext::GetCallingAbility()
{
HILOG_INFO("%{public}s begin.", __func__);
std::shared_ptr<ElementName> elementName = std::make_shared<ElementName>();
if (elementName == nullptr) {
@ -143,7 +141,7 @@ std::shared_ptr<ElementName> AbilityContext::GetCallingAbility()
elementName->SetBundleName(callingBundleName_);
elementName->SetDeviceID(callingDeviceId_);
elementName->SetModuleName(callingModuleName_);
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
return elementName;
}
@ -158,7 +156,7 @@ bool AbilityContext::ConnectAbility(const Want &want, const sptr<AAFwk::IAbility
return false;
}
HILOG_INFO("Connect ability begin, ability:%{public}s.", abilityInfo->name.c_str());
HILOG_DEBUG("Connect ability begin, ability:%{public}s.", abilityInfo->name.c_str());
if (AppExecFwk::AbilityType::PAGE != type && AppExecFwk::AbilityType::SERVICE != type) {
HILOG_ERROR("AbilityContext::ConnectAbility AbilityType = %{public}d", type);
@ -166,12 +164,12 @@ bool AbilityContext::ConnectAbility(const Want &want, const sptr<AAFwk::IAbility
}
ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->ConnectAbility(want, conn, token_);
HILOG_INFO("%{public}s end ConnectAbility, ret=%{public}d", __func__, ret);
HILOG_DEBUG("%{public}s end ConnectAbility, ret=%{public}d", __func__, ret);
bool value = ((ret == ERR_OK) ? true : false);
if (!value) {
HILOG_ERROR("AbilityContext::ConnectAbility ErrorCode = %{public}d", ret);
}
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
return value;
}
@ -179,7 +177,7 @@ ErrCode AbilityContext::DisconnectAbility(const sptr<AAFwk::IAbilityConnection>
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
HILOG_INFO("Disconnect ability begin, caller:%{public}s.", info == nullptr ? "" : info->name.c_str());
HILOG_DEBUG("Disconnect ability begin, caller:%{public}s.", info == nullptr ? "" : info->name.c_str());
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (AppExecFwk::AbilityType::PAGE != type && AppExecFwk::AbilityType::SERVICE != type) {
@ -196,7 +194,7 @@ ErrCode AbilityContext::DisconnectAbility(const sptr<AAFwk::IAbilityConnection>
bool AbilityContext::StopAbility(const AAFwk::Want &want)
{
HILOG_INFO("%{public}s begin.", __func__);
HILOG_DEBUG("%{public}s begin.", __func__);
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (AppExecFwk::AbilityType::PAGE != type && AppExecFwk::AbilityType::SERVICE != type) {
HILOG_ERROR("AbilityContext::StopAbility AbilityType = %{public}d", type);
@ -338,7 +336,7 @@ std::shared_ptr<Global::Resource::ResourceManager> AbilityContext::GetResourceMa
int AbilityContext::VerifyPermission(const std::string &permission, int pid, int uid)
{
HILOG_INFO("%{public}s begin. permission=%{public}s, pid=%{public}d, uid=%{public}d",
HILOG_DEBUG("%{public}s begin. permission=%{public}s, pid=%{public}d, uid=%{public}d",
__func__,
permission.c_str(),
pid,
@ -391,7 +389,6 @@ void AbilityContext::GetPermissionDes(const std::string &permissionName, std::st
void AbilityContext::RequestPermissionsFromUser(std::vector<std::string> &permissions,
std::vector<int> &permissionsState, int requestCode)
{
HILOG_INFO("%{public}s begin.", __func__);
if (permissions.size() == 0) {
HILOG_ERROR("AbilityContext::RequestPermissionsFromUser permissions is empty");
return;
@ -407,7 +404,7 @@ void AbilityContext::RequestPermissionsFromUser(std::vector<std::string> &permis
want.SetParam(PERMISSION_KEY, permissions);
want.SetParam(STATE_KEY, permissionsState);
StartAbility(want, requestCode);
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
}
bool AbilityContext::DeleteFile(const std::string &fileName)
@ -431,7 +428,7 @@ Uri AbilityContext::GetCaller()
void AbilityContext::AttachBaseContext(const std::shared_ptr<Context> &base)
{
HILOG_INFO("AbilityContext::AttachBaseContext.");
HILOG_DEBUG("AbilityContext::AttachBaseContext.");
ContextContainer::AttachBaseContext(base);
}
@ -527,7 +524,6 @@ int AbilityContext::GetThemeId()
bool AbilityContext::TerminateAbilityResult(int startId)
{
HILOG_INFO("%{public}s begin.", __func__);
auto abilityClient = AAFwk::AbilityManagerClient::GetInstance();
if (abilityClient == nullptr) {
HILOG_ERROR("AbilityContext::TerminateAbilityResult abilityClient is nullptr");
@ -541,7 +537,7 @@ bool AbilityContext::TerminateAbilityResult(int startId)
HILOG_ERROR("AbilityContext::TerminateAbilityResult TerminateAbilityResult retval is %d", errval);
}
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
return (errval == ERR_OK) ? true : false;
}
@ -572,11 +568,10 @@ int AbilityContext::GetMissionId()
void AbilityContext::StartAbilities(const std::vector<AAFwk::Want> &wants)
{
HILOG_INFO("%{public}s begin.", __func__);
for (auto want : wants) {
StartAbility(want, ABILITY_CONTEXT_DEFAULT_REQUEST_CODE);
}
HILOG_INFO("%{public}s end.", __func__);
HILOG_DEBUG("%{public}s success.", __func__);
}
bool AbilityContext::IsUpdatingConfigurations()

2
frameworks/native/ability/native/ability_impl_factory.cpp
View File

@ -36,7 +36,7 @@ std::shared_ptr<AbilityImpl> AbilityImplFactory::MakeAbilityImplObject(const std
}
std::shared_ptr<AbilityImpl> abilityImpl = nullptr;
HILOG_INFO("AbilityImplFactory::MakeAbilityImplObject type:%{public}d, isStageBasedModel:%{public}d", info->type,
HILOG_DEBUG("AbilityImplFactory::MakeAbilityImplObject type:%{public}d, isStageBasedModel:%{public}d", info->type,
info->isStageBasedModel);
switch (info->type) {
#ifdef SUPPORT_GRAPHICS

150
frameworks/native/ability/native/ability_thread.cpp
View File

@ -89,7 +89,7 @@ std::string AbilityThread::CreateAbilityName(const std::shared_ptr<AbilityLocalR
}
if (abilityInfo->isNativeAbility) {
HILOG_INFO("Create ability name success, name is %{public}s.", abilityInfo->name.c_str());
HILOG_DEBUG("Create ability name success, name is %{public}s.", abilityInfo->name.c_str());
return abilityInfo->name;
}
#ifdef SUPPORT_GRAPHICS
@ -117,7 +117,7 @@ std::string AbilityThread::CreateAbilityName(const std::shared_ptr<AbilityLocalR
} else if (abilityInfo->type == AbilityType::EXTENSION) {
application->GetExtensionNameByType(static_cast<int32_t>(abilityInfo->extensionAbilityType), abilityName);
if (abilityName.length() > 0) {
HILOG_INFO("Get extension name by plugin success, name: %{public}s", abilityName.c_str());
HILOG_DEBUG("Get extension name by plugin success, name: %{public}s", abilityName.c_str());
return abilityName;
}
abilityName = BASE_SERVICE_EXTENSION;
@ -147,12 +147,12 @@ std::string AbilityThread::CreateAbilityName(const std::shared_ptr<AbilityLocalR
if (abilityInfo->extensionAbilityType == ExtensionAbilityType::ENTERPRISE_ADMIN) {
abilityName = ENTERPRISE_ADMIN_EXTENSION;
}
HILOG_INFO("CreateAbilityName extension type, abilityName:%{public}s", abilityName.c_str());
HILOG_DEBUG("CreateAbilityName extension type, abilityName:%{public}s", abilityName.c_str());
} else {
abilityName = abilityInfo->name;
}
HILOG_INFO("Create ability name success, name is %{public}s.", abilityName.c_str());
HILOG_DEBUG("Create ability name success, name is %{public}s.", abilityName.c_str());
return abilityName;
}
@ -169,7 +169,7 @@ std::string AbilityThread::CreateAbilityName(const std::shared_ptr<AbilityLocalR
std::shared_ptr<ContextDeal> AbilityThread::CreateAndInitContextDeal(std::shared_ptr<OHOSApplication> &application,
const std::shared_ptr<AbilityLocalRecord> &abilityRecord, const std::shared_ptr<Context> &abilityObject)
{
HILOG_INFO("AbilityThread::CreateAndInitContextDeal.");
HILOG_DEBUG("AbilityThread::CreateAndInitContextDeal.");
std::shared_ptr<ContextDeal> contextDeal = nullptr;
if ((application == nullptr) || (abilityRecord == nullptr) || (abilityObject == nullptr)) {
HILOG_ERROR("AbilityThread::ability attach failed,context or record or abilityObject is nullptr");
@ -217,7 +217,7 @@ void AbilityThread::Attach(std::shared_ptr<OHOSApplication> &application,
HILOG_ERROR("Attach ability failed, abilityInfo is nullptr.");
return;
}
HILOG_INFO("Attach ability begin, ability:%{public}s.", abilityRecord->GetAbilityInfo()->name.c_str());
HILOG_DEBUG("Attach ability begin, ability:%{public}s.", abilityRecord->GetAbilityInfo()->name.c_str());
abilityHandler_ = std::make_shared<AbilityHandler>(mainRunner, this);
if (abilityHandler_ == nullptr) {
HILOG_ERROR("Attach ability failed, abilityHandler_ is nullptr.");
@ -325,7 +325,6 @@ void AbilityThread::AttachExtension(std::shared_ptr<OHOSApplication> &applicatio
const std::shared_ptr<AbilityLocalRecord> &abilityRecord)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::AttachExtension begin");
if ((application == nullptr) || (abilityRecord == nullptr)) {
HILOG_ERROR("AbilityThread::AttachExtension failed,context or record is nullptr");
return;
@ -369,7 +368,7 @@ void AbilityThread::AttachExtension(std::shared_ptr<OHOSApplication> &applicatio
HILOG_ERROR("AbilityThread:: AttachExtension failed err = %{public}d", err);
return;
}
HILOG_INFO("AbilityThread::AttachExtension end");
HILOG_DEBUG("AbilityThread::AttachExtension success");
}
/**
@ -382,7 +381,6 @@ void AbilityThread::Attach(
const std::shared_ptr<AbilityRuntime::Context> &stageContext)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::Attach begin");
if ((application == nullptr) || (abilityRecord == nullptr)) {
HILOG_ERROR("AbilityThread::ability attach failed,context or record is nullptr");
return;
@ -435,7 +433,7 @@ void AbilityThread::Attach(
return;
}
HILOG_INFO("AbilityThread::Attach end");
HILOG_DEBUG("AbilityThread::Attach success");
}
/**
@ -446,7 +444,7 @@ void AbilityThread::Attach(
void AbilityThread::HandleAbilityTransaction(const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("Handle ability transaction begin, name is %{public}s.", want.GetElement().GetAbilityName().c_str());
HILOG_DEBUG("Handle ability transaction begin, name is %{public}s.", want.GetElement().GetAbilityName().c_str());
if (abilityImpl_ == nullptr) {
HILOG_ERROR("Handle ability transaction error, abilityImpl_ == nullptr.");
return;
@ -457,7 +455,7 @@ void AbilityThread::HandleAbilityTransaction(const Want &want, const LifeCycleSt
lifeCycleStateInfo.caller.abilityName,
lifeCycleStateInfo.caller.moduleName);
abilityImpl_->HandleAbilityTransaction(want, lifeCycleStateInfo);
HILOG_INFO("Handle ability transaction end.");
HILOG_DEBUG("Handle ability transaction success.");
}
/**
@ -469,13 +467,12 @@ void AbilityThread::HandleAbilityTransaction(const Want &want, const LifeCycleSt
void AbilityThread::HandleExtensionTransaction(const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleExtensionTransaction begin");
if (extensionImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleExtensionTransaction extensionImpl_ == nullptr");
return;
}
extensionImpl_->HandleExtensionTransaction(want, lifeCycleStateInfo);
HILOG_INFO("AbilityThread::HandleAbilityTransaction end");
HILOG_DEBUG("AbilityThread::HandleAbilityTransaction success");
}
/**
@ -485,7 +482,6 @@ void AbilityThread::HandleExtensionTransaction(const Want &want, const LifeCycle
void AbilityThread::HandleConnectAbility(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleConnectAbility begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleConnectAbility abilityImpl_ == nullptr");
return;
@ -496,7 +492,7 @@ void AbilityThread::HandleConnectAbility(const Want &want)
if (err != ERR_OK) {
HILOG_ERROR("AbilityThread:: HandleConnectAbility failed err = %{public}d", err);
}
HILOG_INFO("AbilityThread::HandleConnectAbility end");
HILOG_DEBUG("AbilityThread::HandleConnectAbility success");
}
/**
@ -505,7 +501,6 @@ void AbilityThread::HandleConnectAbility(const Want &want)
void AbilityThread::HandleDisconnectAbility(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("Handle disconnect ability begin.");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("Handle disconnect ability error, abilityImpl_ == nullptr.");
return;
@ -517,6 +512,7 @@ void AbilityThread::HandleDisconnectAbility(const Want &want)
if (err != ERR_OK) {
HILOG_ERROR("Handle disconnect ability error, err = %{public}d.", err);
}
HILOG_DEBUG("Handle disconnect ability success.");
}
/**
@ -534,7 +530,6 @@ void AbilityThread::HandleDisconnectAbility(const Want &want)
void AbilityThread::HandleCommandAbility(const Want &want, bool restart, int startId)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleCommandAbility begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleCommandAbility failed. abilityImpl_ == nullptr");
return;
@ -544,7 +539,7 @@ void AbilityThread::HandleCommandAbility(const Want &want, bool restart, int sta
if (err != ERR_OK) {
HILOG_ERROR("AbilityThread:: HandleCommandAbility failed err = %{public}d", err);
}
HILOG_INFO("AbilityThread::HandleCommandAbility end");
HILOG_DEBUG("AbilityThread::HandleCommandAbility success");
}
/**
@ -555,7 +550,6 @@ void AbilityThread::HandleCommandAbility(const Want &want, bool restart, int sta
void AbilityThread::HandleConnectExtension(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleConnectExtension begin");
if (extensionImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleConnectExtension extensionImpl_ == nullptr");
return;
@ -565,7 +559,7 @@ void AbilityThread::HandleConnectExtension(const Want &want)
if (err != ERR_OK) {
HILOG_ERROR("AbilityThread::HandleConnectExtension failed err = %{public}d", err);
}
HILOG_INFO("AbilityThread::HandleConnectExtension end");
HILOG_DEBUG("AbilityThread::HandleConnectExtension success");
}
/**
@ -574,7 +568,6 @@ void AbilityThread::HandleConnectExtension(const Want &want)
void AbilityThread::HandleDisconnectExtension(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleDisconnectExtension begin");
if (extensionImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleDisconnectExtension extensionImpl_ == nullptr");
return;
@ -584,7 +577,7 @@ void AbilityThread::HandleDisconnectExtension(const Want &want)
if (err != ERR_OK) {
HILOG_ERROR("AbilityThread:: HandleDisconnectExtension failed err = %{public}d", err);
}
HILOG_INFO("AbilityThread::HandleDisconnectExtension end");
HILOG_DEBUG("AbilityThread::HandleDisconnectExtension success");
}
/**
@ -600,7 +593,6 @@ void AbilityThread::HandleDisconnectExtension(const Want &want)
void AbilityThread::HandleCommandExtension(const Want &want, bool restart, int startId)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread::HandleCommandExtension begin");
if (extensionImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleCommandExtension extensionImpl_ == nullptr");
return;
@ -610,7 +602,7 @@ void AbilityThread::HandleCommandExtension(const Want &want, bool restart, int s
if (err != ERR_OK) {
HILOG_ERROR("AbilityThread::HandleCommandExtension failed err = %{public}d", err);
}
HILOG_INFO("AbilityThread::HandleCommandExtension end");
HILOG_DEBUG("AbilityThread::HandleCommandExtension success");
}
/**
@ -619,14 +611,13 @@ void AbilityThread::HandleCommandExtension(const Want &want, bool restart, int s
*/
void AbilityThread::HandleRestoreAbilityState(const PacMap &state)
{
HILOG_INFO("AbilityThread::HandleRestoreAbilityState begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleRestoreAbilityState abilityImpl_ == nullptr");
return;
}
abilityImpl_->DispatchRestoreAbilityState(state);
HILOG_INFO("AbilityThread::HandleRestoreAbilityState end");
HILOG_DEBUG("AbilityThread::HandleRestoreAbilityState success");
}
/**
@ -634,14 +625,13 @@ void AbilityThread::HandleRestoreAbilityState(const PacMap &state)
*/
void AbilityThread::ScheduleSaveAbilityState()
{
HILOG_INFO("AbilityThread::ScheduleSaveAbilityState begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::ScheduleSaveAbilityState abilityImpl_ == nullptr");
return;
}
abilityImpl_->DispatchSaveAbilityState();
HILOG_INFO("AbilityThread::ScheduleSaveAbilityState end");
HILOG_DEBUG("AbilityThread::ScheduleSaveAbilityState success");
}
/**
@ -650,13 +640,12 @@ void AbilityThread::ScheduleSaveAbilityState()
*/
void AbilityThread::ScheduleRestoreAbilityState(const PacMap &state)
{
HILOG_INFO("AbilityThread::ScheduleRestoreAbilityState begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::ScheduleRestoreAbilityState abilityImpl_ == nullptr");
return;
}
abilityImpl_->DispatchRestoreAbilityState(state);
HILOG_INFO("AbilityThread::ScheduleRestoreAbilityState end");
HILOG_DEBUG("AbilityThread::ScheduleRestoreAbilityState success");
}
/*
@ -664,7 +653,6 @@ void AbilityThread::ScheduleRestoreAbilityState(const PacMap &state)
*/
void AbilityThread::ScheduleUpdateConfiguration(const Configuration &config)
{
HILOG_INFO("AbilityThread::ScheduleUpdateConfiguration begin");
wptr<AbilityThread> weak = this;
auto task = [weak, config]() {
auto abilityThread = weak.promote();
@ -689,7 +677,7 @@ void AbilityThread::ScheduleUpdateConfiguration(const Configuration &config)
if (!ret) {
HILOG_ERROR("AbilityThread::ScheduleUpdateConfiguration PostTask error");
}
HILOG_INFO("AbilityThread::ScheduleUpdateConfiguration end");
HILOG_DEBUG("AbilityThread::ScheduleUpdateConfiguration success");
}
/*
@ -697,14 +685,13 @@ void AbilityThread::ScheduleUpdateConfiguration(const Configuration &config)
*/
void AbilityThread::HandleUpdateConfiguration(const Configuration &config)
{
HILOG_INFO("AbilityThread::HandleUpdateConfiguration begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::HandleUpdateConfiguration abilityImpl_ is nullptr");
return;
}
abilityImpl_->ScheduleUpdateConfiguration(config);
HILOG_INFO("AbilityThread::HandleUpdateConfiguration end");
HILOG_DEBUG("AbilityThread::HandleUpdateConfiguration end");
}
void AbilityThread::HandleExtensionUpdateConfiguration(const Configuration &config)
@ -716,7 +703,7 @@ void AbilityThread::HandleExtensionUpdateConfiguration(const Configuration &conf
}
extensionImpl_->ScheduleUpdateConfiguration(config);
HILOG_INFO("AbilityThread::HandleExtensionUpdateConfiguration end");
HILOG_DEBUG("AbilityThread::HandleExtensionUpdateConfiguration success");
}
/**
@ -767,7 +754,7 @@ void AbilityThread::ScheduleAbilityTransaction(const Want &want, const LifeCycle
*/
void AbilityThread::ScheduleConnectAbility(const Want &want)
{
HILOG_INFO("AbilityThread::ScheduleConnectAbility begin, isExtension_:%{public}d", isExtension_);
HILOG_DEBUG("AbilityThread::ScheduleConnectAbility begin, isExtension_:%{public}d", isExtension_);
wptr<AbilityThread> weak = this;
auto task = [weak, want]() {
auto abilityThread = weak.promote();
@ -791,7 +778,7 @@ void AbilityThread::ScheduleConnectAbility(const Want &want)
if (!ret) {
HILOG_ERROR("AbilityThread::ScheduleConnectAbility PostTask error");
}
HILOG_INFO("AbilityThread::ScheduleConnectAbility end");
HILOG_DEBUG("AbilityThread::ScheduleConnectAbility end");
}
/**
@ -801,7 +788,7 @@ void AbilityThread::ScheduleConnectAbility(const Want &want)
void AbilityThread::ScheduleDisconnectAbility(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("Schedule disconnect ability begin, isExtension:%{public}d.", isExtension_);
HILOG_DEBUG("Schedule disconnect ability begin, isExtension:%{public}d.", isExtension_);
wptr<AbilityThread> weak = this;
auto task = [weak, want]() {
auto abilityThread = weak.promote();
@ -841,7 +828,7 @@ void AbilityThread::ScheduleDisconnectAbility(const Want &want)
*/
void AbilityThread::ScheduleCommandAbility(const Want &want, bool restart, int startId)
{
HILOG_INFO("AbilityThread::ScheduleCommandAbility begin. startId:%{public}d", startId);
HILOG_DEBUG("AbilityThread::ScheduleCommandAbility begin. startId:%{public}d", startId);
wptr<AbilityThread> weak = this;
auto task = [weak, want, restart, startId]() {
auto abilityThread = weak.promote();
@ -865,7 +852,7 @@ void AbilityThread::ScheduleCommandAbility(const Want &want, bool restart, int s
if (!ret) {
HILOG_ERROR("AbilityThread::ScheduleCommandAbility PostTask error");
}
HILOG_INFO("AbilityThread::ScheduleCommandAbility end");
HILOG_DEBUG("AbilityThread::ScheduleCommandAbility end");
}
/**
@ -881,7 +868,6 @@ void AbilityThread::ScheduleCommandAbility(const Want &want, bool restart, int s
*/
void AbilityThread::SendResult(int requestCode, int resultCode, const Want &want)
{
HILOG_INFO("AbilityThread::SendResult begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::SendResult abilityImpl_ == nullptr");
return;
@ -907,7 +893,7 @@ void AbilityThread::SendResult(int requestCode, int resultCode, const Want &want
if (!ret) {
HILOG_ERROR("AbilityThread::SendResult PostTask error");
}
HILOG_INFO("AbilityThread::SendResult end");
HILOG_DEBUG("AbilityThread::SendResult success");
}
/**
@ -920,7 +906,6 @@ void AbilityThread::SendResult(int requestCode, int resultCode, const Want &want
*/
std::vector<std::string> AbilityThread::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
{
HILOG_INFO("AbilityThread::GetFileTypes begin");
std::vector<std::string> types;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::GetFileTypes abilityImpl_ is nullptr");
@ -928,7 +913,7 @@ std::vector<std::string> AbilityThread::GetFileTypes(const Uri &uri, const std::
}
types = abilityImpl_->GetFileTypes(uri, mimeTypeFilter);
HILOG_INFO("AbilityThread::GetFileTypes end");
HILOG_DEBUG("AbilityThread::GetFileTypes success");
return types;
}
@ -945,7 +930,6 @@ std::vector<std::string> AbilityThread::GetFileTypes(const Uri &uri, const std::
*/
int AbilityThread::OpenFile(const Uri &uri, const std::string &mode)
{
HILOG_INFO("AbilityThread::OpenFile begin");
int fd = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::OpenFile abilityImpl_ is nullptr");
@ -953,7 +937,7 @@ int AbilityThread::OpenFile(const Uri &uri, const std::string &mode)
}
fd = abilityImpl_->OpenFile(uri, mode);
HILOG_INFO("AbilityThread::OpenFile end");
HILOG_DEBUG("AbilityThread::OpenFile success");
return fd;
}
@ -971,7 +955,6 @@ int AbilityThread::OpenFile(const Uri &uri, const std::string &mode)
*/
int AbilityThread::OpenRawFile(const Uri &uri, const std::string &mode)
{
HILOG_INFO("AbilityThread::OpenRawFile begin");
int fd = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::OpenRawFile abilityImpl_ is nullptr");
@ -979,7 +962,7 @@ int AbilityThread::OpenRawFile(const Uri &uri, const std::string &mode)
}
fd = abilityImpl_->OpenRawFile(uri, mode);
HILOG_INFO("AbilityThread::OpenRawFile end");
HILOG_DEBUG("AbilityThread::OpenRawFile success");
return fd;
}
@ -993,7 +976,6 @@ int AbilityThread::OpenRawFile(const Uri &uri, const std::string &mode)
*/
int AbilityThread::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
{
HILOG_INFO("AbilityThread::Insert begin");
int index = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Insert abilityImpl_ is nullptr");
@ -1001,21 +983,20 @@ int AbilityThread::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
}
index = abilityImpl_->Insert(uri, value);
HILOG_INFO("AbilityThread::Insert end");
HILOG_DEBUG("AbilityThread::Insert success");
return index;
}
std::shared_ptr<AppExecFwk::PacMap> AbilityThread::Call(
const Uri &uri, const std::string &method, const std::string &arg, const AppExecFwk::PacMap &pacMap)
{
HILOG_INFO("AbilityThread::Call begin");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Insert abilityImpl_ is nullptr");
return nullptr;
}
std::shared_ptr<AppExecFwk::PacMap> result = abilityImpl_->Call(uri, method, arg, pacMap);
HILOG_INFO("AbilityThread::Call end");
HILOG_DEBUG("AbilityThread::Call success");
return result;
}
@ -1031,7 +1012,6 @@ std::shared_ptr<AppExecFwk::PacMap> AbilityThread::Call(
int AbilityThread::Update(
const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_INFO("AbilityThread::Update begin");
int index = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Update abilityImpl_ is nullptr");
@ -1039,7 +1019,7 @@ int AbilityThread::Update(
}
index = abilityImpl_->Update(uri, value, predicates);
HILOG_INFO("AbilityThread::Update end");
HILOG_DEBUG("AbilityThread::Update success");
return index;
}
@ -1053,14 +1033,13 @@ int AbilityThread::Update(
*/
int AbilityThread::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_INFO("AbilityThread::Delete begin");
int index = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Delete abilityImpl_ is nullptr");
return index;
}
index = abilityImpl_->Delete(uri, predicates);
HILOG_INFO("AbilityThread::Delete end");
HILOG_DEBUG("AbilityThread::Delete success");
return index;
}
@ -1076,7 +1055,6 @@ int AbilityThread::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates
std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityThread::Query(
const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_INFO("AbilityThread::Query begin");
std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = nullptr;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Query abilityImpl_ is nullptr");
@ -1084,7 +1062,7 @@ std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityThread::Query(
}
resultSet = abilityImpl_->Query(uri, columns, predicates);
HILOG_INFO("AbilityThread::Query end");
HILOG_DEBUG("AbilityThread::Query success");
return resultSet;
}
@ -1098,7 +1076,6 @@ std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityThread::Query(
*/
std::string AbilityThread::GetType(const Uri &uri)
{
HILOG_INFO("AbilityThread::GetType begin");
std::string type;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::GetType abilityImpl_ is nullptr");
@ -1106,7 +1083,7 @@ std::string AbilityThread::GetType(const Uri &uri)
}
type = abilityImpl_->GetType(uri);
HILOG_INFO("AbilityThread::GetType end");
HILOG_DEBUG("AbilityThread::GetType success");
return type;
}
@ -1122,14 +1099,13 @@ std::string AbilityThread::GetType(const Uri &uri)
*/
bool AbilityThread::Reload(const Uri &uri, const PacMap &extras)
{
HILOG_INFO("AbilityThread::Reload begin");
bool ret = false;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::Reload abilityImpl_ is nullptr");
return ret;
}
ret = abilityImpl_->Reload(uri, extras);
HILOG_INFO("AbilityThread::Reload end");
HILOG_DEBUG("AbilityThread::Reload success");
return ret;
}
@ -1143,7 +1119,6 @@ bool AbilityThread::Reload(const Uri &uri, const PacMap &extras)
*/
int AbilityThread::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
{
HILOG_INFO("AbilityThread::BatchInsert begin");
int ret = -1;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::BatchInsert abilityImpl_ is nullptr");
@ -1151,13 +1126,13 @@ int AbilityThread::BatchInsert(const Uri &uri, const std::vector<NativeRdb::Valu
}
ret = abilityImpl_->BatchInsert(uri, values);
HILOG_INFO("AbilityThread::BatchInsert end");
HILOG_DEBUG("AbilityThread::BatchInsert success");
return ret;
}
void AbilityThread::ContinueAbility(const std::string& deviceId, uint32_t versionCode)
{
HILOG_INFO("ContinueAbility");
HILOG_DEBUG("ContinueAbility");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::ContinueAbility abilityImpl_ is nullptr");
return;
@ -1167,7 +1142,7 @@ void AbilityThread::ContinueAbility(const std::string& deviceId, uint32_t versio
void AbilityThread::NotifyContinuationResult(int32_t result)
{
HILOG_INFO("NotifyContinuationResult, result:%{public}d", result);
HILOG_DEBUG("NotifyContinuationResult, result:%{public}d", result);
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::NotifyContinuationResult abilityImpl_ is nullptr");
return;
@ -1187,7 +1162,6 @@ void AbilityThread::AbilityThreadMain(std::shared_ptr<OHOSApplication> &applicat
const std::shared_ptr<AbilityRuntime::Context> &stageContext)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread main start.");
sptr<AbilityThread> thread = sptr<AbilityThread>(new (std::nothrow) AbilityThread());
if (thread == nullptr) {
HILOG_ERROR("AbilityThread::AbilityThreadMain failed,thread is nullptr");
@ -1199,7 +1173,7 @@ void AbilityThread::AbilityThreadMain(std::shared_ptr<OHOSApplication> &applicat
} else {
thread->Attach(application, abilityRecord, mainRunner, stageContext);
}
HILOG_INFO("AbilityThread main end.");
HILOG_DEBUG("AbilityThread main success.");
}
/**
@ -1213,7 +1187,6 @@ void AbilityThread::AbilityThreadMain(
const std::shared_ptr<AbilityRuntime::Context> &stageContext)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("AbilityThread main start.");
sptr<AbilityThread> thread = sptr<AbilityThread>(new (std::nothrow) AbilityThread());
if (thread == nullptr || abilityRecord == nullptr) {
HILOG_ERROR("AbilityThread::AbilityThreadMain failed, thread is nullptr");
@ -1225,12 +1198,12 @@ void AbilityThread::AbilityThreadMain(
} else {
thread->Attach(application, abilityRecord, stageContext);
}
HILOG_INFO("AbilityThread main end.");
HILOG_DEBUG("AbilityThread main success.");
}
void AbilityThread::InitExtensionFlag(const std::shared_ptr<AbilityLocalRecord> &abilityRecord)
{
HILOG_INFO("AbilityThread::InitExtensionFlag start");
HILOG_DEBUG("AbilityThread::InitExtensionFlag start");
if (abilityRecord == nullptr) {
HILOG_ERROR("AbilityThread::InitExtensionFlag abilityRecord null");
return;
@ -1262,7 +1235,6 @@ void AbilityThread::InitExtensionFlag(const std::shared_ptr<AbilityLocalRecord>
*/
Uri AbilityThread::NormalizeUri(const Uri &uri)
{
HILOG_INFO("AbilityThread::NormalizeUri begin");
Uri urivalue("");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("DataAbilityHelper::normalizeUri failed dataAbility == nullptr");
@ -1270,7 +1242,7 @@ Uri AbilityThread::NormalizeUri(const Uri &uri)
}
urivalue = abilityImpl_->NormalizeUri(uri);
HILOG_INFO("AbilityThread::NormalizeUri end");
HILOG_DEBUG("AbilityThread::NormalizeUri success");
return urivalue;
}
@ -1286,7 +1258,6 @@ Uri AbilityThread::NormalizeUri(const Uri &uri)
*/
Uri AbilityThread::DenormalizeUri(const Uri &uri)
{
HILOG_INFO("AbilityThread::DenormalizeUri begin");
Uri urivalue("");
if (abilityImpl_ == nullptr) {
HILOG_ERROR("DataAbilityHelper::denormalizeUri failed dataAbility == nullptr");
@ -1294,7 +1265,7 @@ Uri AbilityThread::DenormalizeUri(const Uri &uri)
}
urivalue = abilityImpl_->DenormalizeUri(uri);
HILOG_INFO("AbilityThread::DenormalizeUri end");
HILOG_DEBUG("AbilityThread::DenormalizeUri success");
return urivalue;
}
@ -1370,7 +1341,7 @@ bool AbilityThread::HandleNotifyChange(const Uri &uri)
*/
bool AbilityThread::CheckObsPermission()
{
HILOG_INFO("%{public}s CheckObsPermission() run Permission Checkout", __func__);
HILOG_DEBUG("%{public}s CheckObsPermission() run Permission Checkout", __func__);
return true;
}
@ -1382,7 +1353,7 @@ bool AbilityThread::CheckObsPermission()
*/
bool AbilityThread::ScheduleRegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
{
HILOG_INFO("%{public}s called", __func__);
HILOG_DEBUG("%{public}s called", __func__);
if (!CheckObsPermission()) {
HILOG_ERROR("%{public}s CheckObsPermission() return false", __func__);
return false;
@ -1418,7 +1389,7 @@ bool AbilityThread::ScheduleRegisterObserver(const Uri &uri, const sptr<AAFwk::I
*/
bool AbilityThread::ScheduleUnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
{
HILOG_INFO("%{public}s called", __func__);
HILOG_DEBUG("%{public}s called", __func__);
if (!CheckObsPermission()) {
HILOG_ERROR("%{public}s CheckObsPermission() return false", __func__);
return false;
@ -1453,7 +1424,7 @@ bool AbilityThread::ScheduleUnregisterObserver(const Uri &uri, const sptr<AAFwk:
*/
bool AbilityThread::ScheduleNotifyChange(const Uri &uri)
{
HILOG_INFO("%{public}s called", __func__);
HILOG_DEBUG("%{public}s called", __func__);
if (!CheckObsPermission()) {
HILOG_ERROR("%{public}s CheckObsPermission() return false", __func__);
return false;
@ -1484,7 +1455,6 @@ bool AbilityThread::ScheduleNotifyChange(const Uri &uri)
std::vector<std::shared_ptr<DataAbilityResult>> AbilityThread::ExecuteBatch(
const std::vector<std::shared_ptr<DataAbilityOperation>> &operations)
{
HILOG_INFO("AbilityThread::ExecuteBatch start");
std::vector<std::shared_ptr<DataAbilityResult>> results;
if (abilityImpl_ == nullptr) {
HILOG_ERROR("AbilityThread::ExecuteBatch abilityImpl_ is nullptr");
@ -1492,7 +1462,7 @@ std::vector<std::shared_ptr<DataAbilityResult>> AbilityThread::ExecuteBatch(
return results;
}
results = abilityImpl_->ExecuteBatch(operations);
HILOG_INFO("AbilityThread::ExecuteBatch end");
HILOG_DEBUG("AbilityThread::ExecuteBatch success");
return results;
}
@ -1510,7 +1480,7 @@ std::shared_ptr<AbilityRuntime::AbilityContext> AbilityThread::BuildAbilityConte
void AbilityThread::DumpAbilityInfo(const std::vector<std::string> &params, std::vector<std::string> &info)
{
HILOG_INFO("%{public}s begin.", __func__);
HILOG_DEBUG("%{public}s begin.", __func__);
if (token_ == nullptr) {
HILOG_ERROR("DumpAbilityInfo::failed, token_ nullptr");
return;
@ -1574,7 +1544,7 @@ void AbilityThread::DumpAbilityInfoInner(const std::vector<std::string> &params,
#else
void AbilityThread::DumpAbilityInfoInner(const std::vector<std::string> &params, std::vector<std::string> &info)
{
HILOG_INFO("%{public}s begin.", __func__);
HILOG_DEBUG("%{public}s begin.", __func__);
if (currentAbility_ != nullptr) {
currentAbility_->Dump(params, info);
}
@ -1591,12 +1561,12 @@ void AbilityThread::DumpOtherInfo(std::vector<std::string> &info)
std::string dumpInfo = " event:";
info.push_back(dumpInfo);
if (!abilityHandler_) {
HILOG_INFO("abilityHandler_ is nullptr.");
HILOG_ERROR("abilityHandler_ is nullptr.");
return;
}
auto runner = abilityHandler_->GetEventRunner();
if (!runner) {
HILOG_INFO("runner_ is nullptr.");
HILOG_ERROR("runner_ is nullptr.");
return;
}
dumpInfo = "";
@ -1605,12 +1575,12 @@ void AbilityThread::DumpOtherInfo(std::vector<std::string> &info)
if (currentAbility_ != nullptr) {
const auto ablityContext = currentAbility_->GetAbilityContext();
if (!ablityContext) {
HILOG_INFO("current ability context is nullptr.");
HILOG_ERROR("current ability context is nullptr.");
return;
}
const auto localCallContainer = ablityContext->GetLocalCallContainer();
if (!localCallContainer) {
HILOG_INFO("current ability context locall call container is nullptr.");
HILOG_ERROR("current ability context locall call container is nullptr.");
return;
}
localCallContainer->DumpCalls(info);
@ -1619,8 +1589,6 @@ void AbilityThread::DumpOtherInfo(std::vector<std::string> &info)
sptr<IRemoteObject> AbilityThread::CallRequest()
{
HILOG_INFO("AbilityThread::CallRequest begin");
if (!currentAbility_) {
HILOG_ERROR("ability is nullptr.");
return nullptr;
@ -1645,7 +1613,7 @@ sptr<IRemoteObject> AbilityThread::CallRequest()
abilityHandler_->PostSyncTask(syncTask);
HILOG_INFO("AbilityThread::CallRequest end");
HILOG_DEBUG("AbilityThread::CallRequest success");
return retval;
}

8
frameworks/native/appkit/ability_runtime/app/ability_stage.cpp
View File

@ -39,12 +39,12 @@ std::shared_ptr<AbilityStage> AbilityStage::Create(
void AbilityStage::OnCreate(const AAFwk::Want &want) const
{
HILOG_INFO("AbilityStage OnCreate come.");
HILOG_DEBUG("AbilityStage OnCreate come.");
}
void AbilityStage::OnDestory() const
{
HILOG_INFO("AbilityStage::OnDestory come");
HILOG_DEBUG("AbilityStage::OnDestory come");
}
std::shared_ptr<Context> AbilityStage::GetContext() const
@ -89,13 +89,13 @@ bool AbilityStage::ContainsAbility()
std::string AbilityStage::OnAcceptWant(const AAFwk::Want &want)
{
HILOG_INFO("AbilityStage::OnAcceptWant come");
HILOG_DEBUG("AbilityStage::OnAcceptWant come");
return "";
}
void AbilityStage::OnConfigurationUpdated(const AppExecFwk::Configuration& configuration)
{
HILOG_INFO("%{public}s called.", __func__);
HILOG_DEBUG("%{public}s called.", __func__);
}
} // namespace AbilityRuntime
} // namespace OHOS

89
frameworks/native/appkit/app/context_deal.cpp
View File

@ -73,7 +73,7 @@ std::shared_ptr<ProcessInfo> ContextDeal::GetProcessInfo() const
*/
void ContextDeal::SetProcessInfo(const std::shared_ptr<ProcessInfo> &info)
{
HILOG_INFO("ContextDeal::SetProcessInfo");
HILOG_DEBUG("ContextDeal::SetProcessInfo");
if (info == nullptr) {
HILOG_ERROR("ContextDeal::SetProcessInfo failed, info is empty");
return;
@ -99,7 +99,7 @@ std::shared_ptr<ApplicationInfo> ContextDeal::GetApplicationInfo() const
*/
void ContextDeal::SetApplicationInfo(const std::shared_ptr<ApplicationInfo> &info)
{
HILOG_INFO("ContextDeal::SetApplicationInfo");
HILOG_DEBUG("ContextDeal::SetApplicationInfo");
if (info == nullptr) {
HILOG_ERROR("ContextDeal::SetApplicationInfo failed, info is empty");
return;
@ -124,7 +124,7 @@ std::shared_ptr<Context> ContextDeal::GetApplicationContext() const
*/
void ContextDeal::SetApplicationContext(const std::shared_ptr<Context> &context)
{
HILOG_INFO("ContextDeal::SetApplicationContext");
HILOG_DEBUG("ContextDeal::SetApplicationContext");
if (context == nullptr) {
HILOG_ERROR("ContextDeal::SetApplicationContext failed, context is empty");
return;
@ -182,7 +182,7 @@ const std::shared_ptr<AbilityInfo> ContextDeal::GetAbilityInfo()
*/
void ContextDeal::SetAbilityInfo(const std::shared_ptr<AbilityInfo> &info)
{
HILOG_INFO("ContextDeal::SetAbilityInfo");
HILOG_DEBUG("ContextDeal::SetAbilityInfo");
if (info == nullptr) {
HILOG_ERROR("ContextDeal::SetAbilityInfo failed, info is empty");
return;
@ -207,7 +207,7 @@ std::shared_ptr<Context> ContextDeal::GetContext()
*/
void ContextDeal::SetContext(const std::shared_ptr<Context> &context)
{
HILOG_INFO("ContextDeal::SetContext");
HILOG_DEBUG("ContextDeal::SetContext");
if (context == nullptr) {
HILOG_ERROR("ContextDeal::SetContext failed, context is empty");
return;
@ -223,7 +223,7 @@ void ContextDeal::SetContext(const std::shared_ptr<Context> &context)
*/
sptr<IBundleMgr> ContextDeal::GetBundleManager() const
{
HILOG_INFO("ContextDeal::GetBundleManager");
HILOG_DEBUG("ContextDeal::GetBundleManager");
auto bundleObj =
OHOS::DelayedSingleton<SysMrgClient>::GetInstance()->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
if (bundleObj == nullptr) {
@ -251,7 +251,7 @@ std::shared_ptr<Global::Resource::ResourceManager> ContextDeal::GetResourceManag
*/
void ContextDeal::SetProfile(const std::shared_ptr<Profile> &profile)
{
HILOG_INFO("ContextDeal::SetProfile");
HILOG_DEBUG("ContextDeal::SetProfile");
if (profile == nullptr) {
HILOG_ERROR("ContextDeal::SetProfile failed, profile is nullptr");
return;
@ -278,10 +278,9 @@ std::shared_ptr<Profile> ContextDeal::GetProfile() const
*/
bool ContextDeal::DeleteFile(const std::string &fileName)
{
HILOG_INFO("ContextDeal::DeleteFile begin");
std::string path = GetDataDir() + CONTEXT_DEAL_FILE_SEPARATOR + fileName;
bool ret = OHOS::RemoveFile(path);
HILOG_INFO("ContextDeal::DeleteFile end");
HILOG_DEBUG("ContextDeal::DeleteFile success");
return ret;
}
@ -386,18 +385,17 @@ std::string ContextDeal::GetDataDir()
*/
std::string ContextDeal::GetDir(const std::string &name, int mode)
{
HILOG_INFO("ContextDeal::GetDir begin");
if (applicationInfo_ == nullptr) {
HILOG_ERROR("ContextDeal::GetDir failed, applicationInfo_ == nullptr");
return "";
}
std::string dir = applicationInfo_->dataDir + CONTEXT_DEAL_FILE_SEPARATOR + name;
if (!OHOS::FileExists(dir)) {
HILOG_INFO("ContextDeal::GetDir File is not exits");
HILOG_ERROR("ContextDeal::GetDir File is not exits");
OHOS::ForceCreateDirectory(dir);
OHOS::ChangeModeDirectory(dir, mode);
}
HILOG_INFO("ContextDeal::GetDir end");
HILOG_DEBUG("ContextDeal::GetDir success");
return dir;
}
@ -449,10 +447,10 @@ std::string ContextDeal::GetFilesDir()
*/
std::string ContextDeal::GetNoBackupFilesDir()
{
HILOG_INFO("ContextDeal::GetNoBackupFilesDir begin");
HILOG_DEBUG("ContextDeal::GetNoBackupFilesDir begin");
std::string dir = GetDataDir() + CONTEXT_DEAL_FILE_SEPARATOR + CONTEXT_DEAL_NO_BACKUP_Files;
if (!OHOS::FileExists(dir)) {
HILOG_INFO("ContextDeal::GetDir GetNoBackupFilesDir is not exits");
HILOG_ERROR("ContextDeal::GetDir GetNoBackupFilesDir is not exits");
OHOS::ForceCreateDirectory(dir);
OHOS::ChangeModeDirectory(dir, MODE);
}
@ -523,7 +521,7 @@ std::string ContextDeal::GetBundleResourcePath()
*/
ErrCode ContextDeal::StartAbility(const AAFwk::Want &want, int requestCode)
{
HILOG_INFO("ContextDeal::StartAbility is called");
HILOG_DEBUG("ContextDeal::StartAbility is called");
return ERR_INVALID_VALUE;
}
@ -546,14 +544,13 @@ void ContextDeal::UnauthUriPermission(const std::string &permission, const Uri &
*/
sptr<AAFwk::IAbilityManager> ContextDeal::GetAbilityManager()
{
HILOG_INFO("ContextDeal::GetAbilityManager begin");
auto remoteObject = OHOS::DelayedSingleton<SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
if (remoteObject == nullptr) {
HILOG_ERROR("failed to get ability manager service");
return nullptr;
}
sptr<AAFwk::IAbilityManager> ams = iface_cast<AAFwk::IAbilityManager>(remoteObject);
HILOG_INFO("ContextDeal::GetAbilityManager end");
HILOG_DEBUG("ContextDeal::GetAbilityManager success");
return ams;
}
@ -567,14 +564,13 @@ sptr<AAFwk::IAbilityManager> ContextDeal::GetAbilityManager()
*/
std::string ContextDeal::GetAppType()
{
HILOG_INFO("ContextDeal::GetAppType begin");
sptr<IBundleMgr> ptr = GetBundleManager();
if (ptr == nullptr) {
HILOG_ERROR("GetAppType failed to get bundle manager service");
return "";
}
std::string retString = ptr->GetAppType(applicationInfo_->bundleName);
HILOG_INFO("ContextDeal::GetAppType end");
HILOG_DEBUG("ContextDeal::GetAppType success");
return retString;
}
@ -619,12 +615,12 @@ int ContextDeal::GetCurrentAccountId() const
void ContextDeal::CreateDirIfNotExist(const std::string &dirPath) const
{
HILOG_INFO("CreateDirIfNotExist: create directory if not exists.");
HILOG_DEBUG("CreateDirIfNotExist: create directory if not exists.");
if (!OHOS::FileExists(dirPath)) {
HILOG_INFO("ContextDeal::CreateDirIfNotExist File is not exits");
HILOG_DEBUG("ContextDeal::CreateDirIfNotExist File is not exits");
bool createDir = OHOS::ForceCreateDirectory(dirPath);
if (!createDir) {
HILOG_INFO("CreateDirIfNotExist: create dir %{public}s failed.", dirPath.c_str());
HILOG_ERROR("CreateDirIfNotExist: create dir %{public}s failed.", dirPath.c_str());
return;
}
}
@ -639,7 +635,6 @@ void ContextDeal::CreateDirIfNotExist(const std::string &dirPath) const
*/
std::string ContextDeal::GetDistributedDir()
{
HILOG_INFO("ContextDeal::GetDistributedDir");
std::string dir;
if (IsCreateBySystemApp()) {
dir = CONTEXT_DISTRIBUTED_BASE_BEFORE + std::to_string(GetCurrentAccountId()) +
@ -648,7 +643,7 @@ std::string ContextDeal::GetDistributedDir()
dir = CONTEXT_DATA_STORAGE + currArea_ + CONTEXT_DEAL_FILE_SEPARATOR + CONTEXT_DEAL_DISTRIBUTEDFILES;
}
CreateDirIfNotExist(dir);
HILOG_INFO("ContextDeal::GetDistributedDir:%{public}s", dir.c_str());
HILOG_DEBUG("ContextDeal::GetDistributedDir:%{public}s", dir.c_str());
return dir;
}
/**
@ -658,7 +653,6 @@ std::string ContextDeal::GetDistributedDir()
*/
void ContextDeal::SetPattern(int patternId)
{
HILOG_INFO("ContextDeal::SetPattern begin");
if (resourceManager_ != nullptr) {
if (!pattern_.empty()) {
pattern_.clear();
@ -670,7 +664,7 @@ void ContextDeal::SetPattern(int patternId)
} else {
HILOG_ERROR("ContextDeal::SetPattern resourceManager_ is nullptr");
}
HILOG_INFO("ContextDeal::SetPattern end");
HILOG_DEBUG("ContextDeal::SetPattern success");
}
/**
@ -698,7 +692,7 @@ std::shared_ptr<HapModuleInfo> ContextDeal::GetHapModuleInfo()
return nullptr;
}
}
HILOG_INFO("ContextDeal::GetHapModuleInfo end");
HILOG_DEBUG("ContextDeal::GetHapModuleInfo success");
return hapModuleInfoLocal_;
}
@ -804,9 +798,8 @@ sptr<IRemoteObject> ContextDeal::GetToken()
*/
void ContextDeal::initResourceManager(const std::shared_ptr<Global::Resource::ResourceManager> &resourceManager)
{
HILOG_INFO("ContextDeal::initResourceManager. Start.");
resourceManager_ = resourceManager;
HILOG_INFO("ContextDeal::initResourceManager. End.");
HILOG_DEBUG("ContextDeal::initResourceManager success.");
}
/**
@ -837,7 +830,6 @@ void ContextDeal::SerUriString(const std::string &uri)
*/
std::string ContextDeal::GetString(int resId)
{
HILOG_INFO("ContextDeal::GetString begin");
if (resourceManager_ == nullptr) {
HILOG_ERROR("ContextDeal::GetString resourceManager_ is nullptr");
return "";
@ -851,7 +843,7 @@ std::string ContextDeal::GetString(int resId)
HILOG_ERROR("ContextDeal::GetString GetStringById(resId:%d) retval is %u", resId, errval);
return "";
}
HILOG_INFO("ContextDeal::GetString end");
HILOG_DEBUG("ContextDeal::GetString success");
}
/**
@ -863,7 +855,6 @@ std::string ContextDeal::GetString(int resId)
*/
std::vector<std::string> ContextDeal::GetStringArray(int resId)
{
HILOG_INFO("ContextDeal::GetStringArray begin");
if (resourceManager_ == nullptr) {
HILOG_ERROR("ContextDeal::GetStringArray resourceManager_ is nullptr");
return std::vector<std::string>();
@ -877,7 +868,7 @@ std::vector<std::string> ContextDeal::GetStringArray(int resId)
HILOG_ERROR("ContextDeal::GetStringArray GetStringArrayById(resId:%d) retval is %u", resId, errval);
return std::vector<std::string>();
}
HILOG_INFO("ContextDeal::GetStringArray end");
HILOG_DEBUG("ContextDeal::GetStringArray success");
}
/**
@ -889,7 +880,6 @@ std::vector<std::string> ContextDeal::GetStringArray(int resId)
*/
std::vector<int> ContextDeal::GetIntArray(int resId)
{
HILOG_INFO("ContextDeal::GetIntArray begin");
if (resourceManager_ == nullptr) {
HILOG_ERROR("ContextDeal::GetIntArray resourceManager_ is nullptr");
return std::vector<int>();
@ -903,7 +893,7 @@ std::vector<int> ContextDeal::GetIntArray(int resId)
HILOG_ERROR("ContextDeal::GetIntArray GetIntArrayById(resId:%d) retval is %u", resId, errval);
return std::vector<int>();
}
HILOG_INFO("ContextDeal::GetIntArray end");
HILOG_DEBUG("ContextDeal::GetIntArray success");
}
/**
@ -913,11 +903,10 @@ std::vector<int> ContextDeal::GetIntArray(int resId)
*/
std::map<std::string, std::string> ContextDeal::GetTheme()
{
HILOG_INFO("ContextDeal::GetTheme begin");
if (theme_.empty()) {
SetTheme(GetThemeId());
}
HILOG_INFO("ContextDeal::GetTheme end");
HILOG_DEBUG("ContextDeal::GetTheme success");
return theme_;
}
@ -928,7 +917,6 @@ std::map<std::string, std::string> ContextDeal::GetTheme()
*/
void ContextDeal::SetTheme(int themeId)
{
HILOG_INFO("ContextDeal::SetTheme begin");
if (resourceManager_ == nullptr) {
HILOG_ERROR("ContextDeal::SetTheme resourceManager_ is nullptr");
return;
@ -949,7 +937,7 @@ void ContextDeal::SetTheme(int themeId)
return;
}
HILOG_INFO("ContextDeal::SetTheme end");
HILOG_DEBUG("ContextDeal::SetTheme success");
return;
}
@ -960,9 +948,9 @@ void ContextDeal::SetTheme(int themeId)
*/
std::map<std::string, std::string> ContextDeal::GetPattern()
{
HILOG_INFO("ContextDeal::GetPattern begin");
HILOG_DEBUG("ContextDeal::GetPattern begin");
if (!pattern_.empty()) {
HILOG_INFO("ContextDeal::GetPattern end");
HILOG_DEBUG("ContextDeal::GetPattern end");
return pattern_;
} else {
HILOG_ERROR("ContextDeal::GetPattern pattern_ is empty");
@ -979,7 +967,6 @@ std::map<std::string, std::string> ContextDeal::GetPattern()
*/
int ContextDeal::GetColor(int resId)
{
HILOG_INFO("ContextDeal::GetColor begin");
if (resourceManager_ == nullptr) {
HILOG_ERROR("ContextDeal::GetColor resourceManager_ is nullptr");
return INVALID_RESOURCE_VALUE;
@ -993,7 +980,7 @@ int ContextDeal::GetColor(int resId)
HILOG_ERROR("ContextDeal::GetColor GetColorById(resId:%d) retval is %u", resId, errval);
return INVALID_RESOURCE_VALUE;
}
HILOG_INFO("ContextDeal::GetColor end");
HILOG_DEBUG("ContextDeal::GetColor success");
}
/**
@ -1039,9 +1026,9 @@ bool ContextDeal::TerminateAbilityResult(int startId)
*/
int ContextDeal::GetDisplayOrientation()
{
HILOG_INFO("ContextDeal::GetDisplayOrientation begin");
HILOG_DEBUG("ContextDeal::GetDisplayOrientation begin");
if (abilityInfo_ != nullptr) {
HILOG_INFO("ContextDeal::GetDisplayOrientation end");
HILOG_DEBUG("ContextDeal::GetDisplayOrientation end");
return static_cast<int>(abilityInfo_->orientation);
} else {
HILOG_ERROR("ContextDeal::GetDisplayOrientation abilityInfo_ is nullptr");
@ -1057,7 +1044,7 @@ int ContextDeal::GetDisplayOrientation()
*/
std::string ContextDeal::GetPreferencesDir()
{
HILOG_INFO("ContextDeal::GetPreferencesDir begin");
HILOG_DEBUG("ContextDeal::GetPreferencesDir begin");
std::string dir = GetBaseDir() + CONTEXT_DEAL_FILE_SEPARATOR + CONTEXT_DEAL_PREFERENCES;
CreateDirIfNotExist(dir);
HILOG_DEBUG("ContextDeal::GetPreferencesDir:%{public}s", dir.c_str());
@ -1071,7 +1058,6 @@ std::string ContextDeal::GetPreferencesDir()
*/
void ContextDeal::SetColorMode(int mode)
{
HILOG_INFO("ContextDeal::SetColorMode begin");
auto hapModInfo = GetHapModuleInfo();
if (hapModInfo == nullptr) {
HILOG_ERROR("ContextDeal::SetColorMode hapModInfo is nullptr");
@ -1085,7 +1071,7 @@ void ContextDeal::SetColorMode(int mode)
} else { // default use AUTO
hapModInfo->colorMode = ModuleColorMode::AUTO;
}
HILOG_INFO("ContextDeal::SetColorMode end");
HILOG_DEBUG("ContextDeal::SetColorMode success");
}
/**
@ -1095,13 +1081,12 @@ void ContextDeal::SetColorMode(int mode)
*/
int ContextDeal::GetColorMode()
{
HILOG_INFO("ContextDeal::GetColorMode begin");
auto hapModInfo = GetHapModuleInfo();
if (hapModInfo == nullptr) {
HILOG_ERROR("ContextDeal::GetColorMode hapModInfo is nullptr");
return -1;
}
HILOG_INFO("ContextDeal::GetColorMode end");
HILOG_DEBUG("ContextDeal::GetColorMode success");
return static_cast<int>(hapModInfo->colorMode);
}
@ -1160,8 +1145,6 @@ void ContextDeal::SetRunner(const std::shared_ptr<EventRunner> &runner)
*/
bool ContextDeal::HapModuleInfoRequestInit()
{
HILOG_INFO("ContextDeal::HapModuleInfoRequestInit begin");
sptr<IBundleMgr> ptr = GetBundleManager();
if (ptr == nullptr) {
HILOG_ERROR("GetHapModuleInfo failed to get bundle manager service");
@ -1178,7 +1161,7 @@ bool ContextDeal::HapModuleInfoRequestInit()
HILOG_ERROR("IBundleMgr::GetHapModuleInfo failed, will retval false value");
return false;
}
HILOG_INFO("ContextDeal::HapModuleInfoRequestInit end");
HILOG_DEBUG("ContextDeal::HapModuleInfoRequestInit success");
return true;
}

106
frameworks/native/appkit/app/main_thread.cpp
View File

@ -208,7 +208,6 @@ std::shared_ptr<ApplicationImpl> MainThread::GetApplicationImpl()
bool MainThread::ConnectToAppMgr()
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread ConnectToAppMgr start.");
auto object = OHOS::DelayedSingleton<SysMrgClient>::GetInstance()->GetSystemAbility(APP_MGR_SERVICE_ID);
if (object == nullptr) {
HILOG_ERROR("failed to get app manager service");
@ -231,7 +230,7 @@ bool MainThread::ConnectToAppMgr()
return false;
}
appMgr_->AttachApplication(this);
HILOG_INFO("MainThread::connectToAppMgr end");
HILOG_DEBUG("MainThread::connectToAppMgr success");
return true;
}
@ -243,13 +242,12 @@ bool MainThread::ConnectToAppMgr()
void MainThread::Attach()
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread attach called.");
if (!ConnectToAppMgr()) {
HILOG_ERROR("attachApplication failed");
return;
}
mainThreadState_ = MainThreadState::ATTACH;
HILOG_INFO("MainThread::attach mainThreadState: %{public}d", mainThreadState_);
HILOG_DEBUG("MainThread::attach mainThreadState: %{public}d", mainThreadState_);
}
/**
@ -259,7 +257,6 @@ void MainThread::Attach()
*/
void MainThread::RemoveAppMgrDeathRecipient()
{
HILOG_INFO("MainThread::RemoveAppMgrDeathRecipient called begin");
if (appMgr_ == nullptr) {
HILOG_ERROR("MainThread::RemoveAppMgrDeathRecipient failed");
return;
@ -271,7 +268,7 @@ void MainThread::RemoveAppMgrDeathRecipient()
} else {
HILOG_ERROR("appMgr_->AsObject() failed");
}
HILOG_INFO("%{public}s called end.", __func__);
HILOG_DEBUG("%{public}s called success.", __func__);
}
/**
@ -293,7 +290,6 @@ std::shared_ptr<EventHandler> MainThread::GetMainHandler() const
void MainThread::ScheduleForegroundApplication()
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("Schedule the application to foreground begin.");
wptr<MainThread> weak = this;
auto task = [weak]() {
auto appThread = weak.promote();
@ -306,7 +302,7 @@ void MainThread::ScheduleForegroundApplication()
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("PostTask task failed");
}
HILOG_INFO("Schedule the application to foreground end.");
HILOG_DEBUG("Schedule the application to foreground success.");
}
/**
@ -316,7 +312,6 @@ void MainThread::ScheduleForegroundApplication()
*/
void MainThread::ScheduleBackgroundApplication()
{
HILOG_INFO("MainThread::scheduleBackgroundApplication called begin");
wptr<MainThread> weak = this;
auto task = [weak]() {
auto appThread = weak.promote();
@ -329,7 +324,7 @@ void MainThread::ScheduleBackgroundApplication()
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleBackgroundApplication PostTask task failed");
}
HILOG_INFO("MainThread::scheduleBackgroundApplication called end.");
HILOG_DEBUG("MainThread::scheduleBackgroundApplication called success.");
}
/**
@ -339,7 +334,6 @@ void MainThread::ScheduleBackgroundApplication()
*/
void MainThread::ScheduleTerminateApplication()
{
HILOG_INFO("MainThread::scheduleTerminateApplication called begin");
wptr<MainThread> weak = this;
auto task = [weak]() {
auto appThread = weak.promote();
@ -352,7 +346,7 @@ void MainThread::ScheduleTerminateApplication()
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleTerminateApplication PostTask task failed");
}
HILOG_INFO("MainThread::scheduleTerminateApplication called.");
HILOG_DEBUG("MainThread::scheduleTerminateApplication called success.");
}
/**
@ -363,7 +357,6 @@ void MainThread::ScheduleTerminateApplication()
*/
void MainThread::ScheduleShrinkMemory(const int level)
{
HILOG_INFO("MainThread::scheduleShrinkMemory level: %{public}d", level);
wptr<MainThread> weak = this;
auto task = [weak, level]() {
auto appThread = weak.promote();
@ -376,7 +369,7 @@ void MainThread::ScheduleShrinkMemory(const int level)
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleShrinkMemory PostTask task failed");
}
HILOG_INFO("MainThread::scheduleShrinkMemory level: %{public}d end.", level);
HILOG_DEBUG("MainThread::scheduleShrinkMemory level: %{public}d end.", level);
}
/**
@ -391,7 +384,6 @@ void MainThread::ScheduleProcessSecurityExit()
void MainThread::PostProcessSecurityExitTask(bool delay)
{
HILOG_INFO("PostProcessSecurityExitTask called start");
wptr<MainThread> weak = this;
auto task = [weak]() {
auto appThread = weak.promote();
@ -410,7 +402,7 @@ void MainThread::PostProcessSecurityExitTask(bool delay)
if (!result) {
HILOG_ERROR("PostProcessSecurityExitTask post task failed");
}
HILOG_INFO("PostProcessSecurityExitTask called end");
HILOG_DEBUG("PostProcessSecurityExitTask called success");
}
/**
@ -420,7 +412,7 @@ void MainThread::PostProcessSecurityExitTask(bool delay)
*/
void MainThread::ScheduleLowMemory()
{
HILOG_INFO("MainThread::scheduleLowMemory called");
HILOG_DEBUG("MainThread::scheduleLowMemory called");
}
/**
@ -433,7 +425,6 @@ void MainThread::ScheduleLowMemory()
void MainThread::ScheduleLaunchApplication(const AppLaunchData &data, const Configuration &config)
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread schedule launch application start.");
wptr<MainThread> weak = this;
auto task = [weak, data, config]() {
auto appThread = weak.promote();
@ -446,11 +437,11 @@ void MainThread::ScheduleLaunchApplication(const AppLaunchData &data, const Conf
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleLaunchApplication PostTask task failed");
}
HILOG_DEBUG("MainThread schedule launch application success.");
}
void MainThread::ScheduleAbilityStage(const HapModuleInfo &abilityStage)
{
HILOG_INFO("MainThread::ScheduleAbilityStageInfo start");
wptr<MainThread> weak = this;
auto task = [weak, abilityStage]() {
auto appThread = weak.promote();
@ -463,14 +454,14 @@ void MainThread::ScheduleAbilityStage(const HapModuleInfo &abilityStage)
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleAbilityStageInfo PostTask task failed");
}
HILOG_INFO("MainThread::ScheduleAbilityStageInfo end.");
HILOG_DEBUG("MainThread::ScheduleAbilityStageInfo success.");
}
void MainThread::ScheduleLaunchAbility(const AbilityInfo &info, const sptr<IRemoteObject> &token,
const std::shared_ptr<AAFwk::Want> &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread schedule launch ability, name is %{public}s, type is %{public}d.",
HILOG_DEBUG("MainThread schedule launch ability, name is %{public}s, type is %{public}d.",
info.name.c_str(), info.type);
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>(info);
@ -500,7 +491,7 @@ void MainThread::ScheduleLaunchAbility(const AbilityInfo &info, const sptr<IRemo
*/
void MainThread::ScheduleCleanAbility(const sptr<IRemoteObject> &token)
{
HILOG_INFO("Schedule clean ability called.");
HILOG_DEBUG("Schedule clean ability called.");
wptr<MainThread> weak = this;
auto task = [weak, token]() {
auto appThread = weak.promote();
@ -524,7 +515,7 @@ void MainThread::ScheduleCleanAbility(const sptr<IRemoteObject> &token)
*/
void MainThread::ScheduleProfileChanged(const Profile &profile)
{
HILOG_INFO("MainThread::scheduleProfileChanged profile name: %{public}s", profile.GetName().c_str());
HILOG_DEBUG("MainThread::scheduleProfileChanged profile name: %{public}s", profile.GetName().c_str());
}
/**
@ -536,7 +527,6 @@ void MainThread::ScheduleProfileChanged(const Profile &profile)
*/
void MainThread::ScheduleConfigurationUpdated(const Configuration &config)
{
HILOG_INFO("MainThread::ScheduleConfigurationUpdated called start.");
wptr<MainThread> weak = this;
auto task = [weak, config]() {
auto appThread = weak.promote();
@ -549,7 +539,7 @@ void MainThread::ScheduleConfigurationUpdated(const Configuration &config)
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::ScheduleConfigurationUpdated PostTask task failed");
}
HILOG_INFO("MainThread::ScheduleConfigurationUpdated called end.");
HILOG_DEBUG("MainThread::ScheduleConfigurationUpdated called success.");
}
bool MainThread::CheckLaunchApplicationParam(const AppLaunchData &appLaunchData) const
@ -606,7 +596,6 @@ bool MainThread::CheckAbilityItem(const std::shared_ptr<AbilityLocalRecord> &rec
*/
void MainThread::HandleTerminateApplicationLocal()
{
HILOG_INFO("MainThread::HandleTerminateApplicationLocal called start.");
if (application_ == nullptr) {
HILOG_ERROR("MainThread::HandleTerminateApplicationLocal error!");
return;
@ -644,7 +633,7 @@ void MainThread::HandleTerminateApplicationLocal()
handleAppLib_ = nullptr;
}
#endif // APPLICATION_LIBRARY_LOADER
HILOG_INFO("MainThread::HandleTerminateApplicationLocal called end.");
HILOG_DEBUG("MainThread::HandleTerminateApplicationLocal called success.");
}
/**
@ -655,7 +644,6 @@ void MainThread::HandleTerminateApplicationLocal()
void MainThread::HandleProcessSecurityExit()
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread::HandleProcessSecurityExit called start.");
if (abilityRecordMgr_ == nullptr) {
HILOG_ERROR("MainThread::HandleProcessSecurityExit abilityRecordMgr_ is null");
return;
@ -668,7 +656,7 @@ void MainThread::HandleProcessSecurityExit()
}
HandleTerminateApplicationLocal();
HILOG_INFO("MainThread::HandleProcessSecurityExit called end.");
HILOG_DEBUG("MainThread::HandleProcessSecurityExit called success.");
}
bool MainThread::InitCreate(
@ -746,7 +734,7 @@ bool MainThread::InitResourceManager(std::shared_ptr<Global::Resource::ResourceM
ChangeToLocalPath(bundleInfo.name, bundleInfo.moduleResPaths, resPaths);
for (auto moduleResPath : resPaths) {
if (!moduleResPath.empty()) {
HILOG_INFO("MainThread::handleLaunchApplication length: %{public}zu, moduleResPath: %{public}s",
HILOG_DEBUG("MainThread::handleLaunchApplication length: %{public}zu, moduleResPath: %{public}s",
moduleResPath.length(),
moduleResPath.c_str());
if (!resourceManager->AddResource(moduleResPath.c_str())) {
@ -818,7 +806,6 @@ static std::string GetNativeStrFromJsTaggedObj(NativeObject* obj, const char* ke
void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, const Configuration &config)
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread handle launch application start.");
if (!CheckForHandleLaunchApplication(appLaunchData)) {
HILOG_ERROR("MainThread::handleLaunchApplication CheckForHandleLaunchApplication failed");
return;
@ -1031,14 +1018,14 @@ void MainThread::HandleLaunchApplication(const AppLaunchData &appLaunchData, con
HILOG_ERROR("HandleLaunchApplication::application pAppEvnIml is null");
}
HILOG_INFO("MainThread::handleLaunchApplication called end.");
HILOG_DEBUG("MainThread::handleLaunchApplication called success.");
}
void MainThread::LoadNativeLiabrary(std::string &nativeLibraryPath)
{
#ifdef ABILITY_LIBRARY_LOADER
if (nativeLibraryPath.empty()) {
HILOG_INFO("Native library path is empty.");
HILOG_ERROR("Native library path is empty.");
return;
}
@ -1047,14 +1034,14 @@ void MainThread::LoadNativeLiabrary(std::string &nativeLibraryPath)
}
std::string libPath = LOCAL_CODE_PATH;
libPath += (libPath.back() == '/') ? nativeLibraryPath : "/" + nativeLibraryPath;
HILOG_INFO("native library path = %{public}s", libPath.c_str());
HILOG_DEBUG("native library path = %{public}s", libPath.c_str());
if (!ScanDir(libPath, nativeFileEntries_)) {
HILOG_INFO("%{public}s scanDir %{public}s not exits", __func__, libPath.c_str());
HILOG_ERROR("%{public}s scanDir %{public}s not exits", __func__, libPath.c_str());
}
if (nativeFileEntries_.empty()) {
HILOG_INFO("No native library");
HILOG_ERROR("No native library");
return;
}
@ -1067,7 +1054,7 @@ void MainThread::LoadNativeLiabrary(std::string &nativeLibraryPath)
__func__, fileEntry.c_str(), dlerror());
exit(-1);
}
HILOG_INFO("%{public}s Success to dlopen %{public}s", __func__, fileEntry.c_str());
HILOG_DEBUG("%{public}s Success to dlopen %{public}s", __func__, fileEntry.c_str());
handleAbilityLib_.emplace_back(handleAbilityLib);
}
}
@ -1090,7 +1077,7 @@ void MainThread::ChangeToLocalPath(const std::string &bundleName,
void MainThread::HandleAbilityStage(const HapModuleInfo &abilityStage)
{
HILOG_INFO("MainThread::HandleAbilityStageInfo");
HILOG_DEBUG("MainThread::HandleAbilityStageInfo");
if (!application_) {
HILOG_ERROR("application_ is nullptr");
return;
@ -1109,13 +1096,13 @@ void MainThread::HandleAbilityStage(const HapModuleInfo &abilityStage)
void MainThread::LoadAndRegisterExtension(const std::string &libName,
const std::string &extensionName, const std::unique_ptr<AbilityRuntime::Runtime>& runtime)
{
HILOG_INFO("MainThread::LoadAndRegisterExtension.libName:%{public}s,extensionName:%{public}s,",
HILOG_DEBUG("MainThread::LoadAndRegisterExtension.libName:%{public}s,extensionName:%{public}s,",
libName.c_str(), extensionName.c_str());
if (application_ == nullptr) {
HILOG_ERROR("LoadAndRegisterExtension::application launch failed");
return;
}
HILOG_INFO("MainThread::LoadAndRegisterExtension load success.");
HILOG_DEBUG("MainThread::LoadAndRegisterExtension load success.");
AbilityLoader::GetInstance().RegisterExtension(extensionName, [application = application_, libName]() {
return AbilityRuntime::ExtensionModuleLoader::GetLoader(libName.c_str()).Create(application->GetRuntime());
});
@ -1524,13 +1511,11 @@ void MainThread::HandleConfigurationUpdated(const Configuration &config)
void MainThread::TaskTimeoutDetected(const std::shared_ptr<EventRunner> &runner)
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread::TaskTimeoutDetected called start.");
auto deliveryTimeoutCallback = []() {
HILOG_INFO("MainThread::TaskTimeoutDetected delivery timeout");
HILOG_DEBUG("MainThread::TaskTimeoutDetected delivery timeout");
};
auto distributeTimeoutCallback = []() {
HILOG_INFO("MainThread::TaskTimeoutDetected distribute timeout");
HILOG_DEBUG("MainThread::TaskTimeoutDetected distribute timeout");
};
if (runner !=nullptr && mainHandler_ != nullptr) {
@ -1540,13 +1525,12 @@ void MainThread::TaskTimeoutDetected(const std::shared_ptr<EventRunner> &runner)
runner->SetDistributeTimeout(DISTRIBUTE_TIME);
mainHandler_->SetDistributeTimeoutCallback(distributeTimeoutCallback);
}
HILOG_INFO("MainThread::TaskTimeoutDetected called end.");
HILOG_DEBUG("MainThread::TaskTimeoutDetected called success.");
}
void MainThread::Init(const std::shared_ptr<EventRunner> &runner, const std::shared_ptr<EventRunner> &watchDogRunner)
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread:Init Start");
mainHandler_ = std::make_shared<MainHandler>(runner, this);
watchDogHandler_ = std::make_shared<WatchDog>(watchDogRunner);
dfxHandler_ = std::make_shared<EventHandler>(EventRunner::Create(DFX_THREAD_NAME));
@ -1560,7 +1544,7 @@ void MainThread::Init(const std::shared_ptr<EventRunner> &runner, const std::sha
appThread->SetRunnerStarted(true);
};
auto taskWatchDog = []() {
HILOG_INFO("MainThread:WatchDogHandler Start");
HILOG_DEBUG("MainThread:WatchDogHandler Start");
};
if (!mainHandler_->PostTask(task)) {
HILOG_ERROR("MainThread::Init PostTask task failed");
@ -1572,7 +1556,7 @@ void MainThread::Init(const std::shared_ptr<EventRunner> &runner, const std::sha
watchDogHandler_->Init(mainHandler_, watchDogHandler_);
TaskHandlerClient::GetInstance()->CreateRunner();
HILOG_INFO("MainThread:Init end.");
HILOG_DEBUG("MainThread:Init success.");
}
void MainThread::HandleSignal(int signal)
@ -1638,7 +1622,7 @@ void MainThread::HandleScheduleANRProcess()
void MainThread::Start()
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
HILOG_INFO("MainThread start come.");
HILOG_DEBUG("MainThread start come.");
std::shared_ptr<EventRunner> runner = EventRunner::GetMainEventRunner();
if (runner == nullptr) {
HILOG_ERROR("MainThread::main failed, runner is nullptr");
@ -1673,7 +1657,7 @@ void MainThread::Start()
}
thread->RemoveAppMgrDeathRecipient();
HILOG_INFO("MainThread::main runner stopped");
HILOG_DEBUG("MainThread::main runner stopped");
}
MainThread::MainHandler::MainHandler(const std::shared_ptr<EventRunner> &runner, const sptr<MainThread> &thread)
@ -1707,7 +1691,7 @@ void MainThread::MainHandler::ProcessEvent(const OHOS::AppExecFwk::InnerEvent::P
*/
bool MainThread::IsApplicationReady() const
{
HILOG_INFO("MainThread::IsApplicationReady called start");
HILOG_DEBUG("MainThread::IsApplicationReady called start");
if (application_ == nullptr || applicationImpl_ == nullptr) {
HILOG_WARN("MainThread::IsApplicationReady called. application_=null or applicationImpl_=null");
return false;
@ -1728,32 +1712,32 @@ void MainThread::LoadAbilityLibrary(const std::vector<std::string> &libraryPaths
{
HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
#ifdef ABILITY_LIBRARY_LOADER
HILOG_INFO("MainThread load ability library start.");
HILOG_DEBUG("MainThread load ability library start.");
#ifdef ACEABILITY_LIBRARY_LOADER
void *AceAbilityLib = nullptr;
AceAbilityLib = dlopen(acelibdir.c_str(), RTLD_NOW | RTLD_GLOBAL);
if (AceAbilityLib == nullptr) {
HILOG_ERROR("Fail to dlopen %{public}s, [%{public}s]", acelibdir.c_str(), dlerror());
} else {
HILOG_INFO("Success to dlopen %{public}s", acelibdir.c_str());
HILOG_DEBUG("Success to dlopen %{public}s", acelibdir.c_str());
handleAbilityLib_.emplace_back(AceAbilityLib);
}
#endif // ACEABILITY_LIBRARY_LOADER
size_t size = libraryPaths.size();
for (size_t index = 0; index < size; index++) {
std::string libraryPath = libraryPaths[index];
HILOG_INFO("MainThread::LoadAbilityLibrary Try to scanDir %{public}s", libraryPath.c_str());
HILOG_DEBUG("MainThread::LoadAbilityLibrary Try to scanDir %{public}s", libraryPath.c_str());
if (!ScanDir(libraryPath, fileEntries_)) {
HILOG_INFO("MainThread::LoadAbilityLibrary scanDir %{public}s not exits", libraryPath.c_str());
HILOG_ERROR("MainThread::LoadAbilityLibrary scanDir %{public}s not exits", libraryPath.c_str());
}
libraryPath = libraryPath + "/libs";
if (!ScanDir(libraryPath, fileEntries_)) {
HILOG_INFO("MainThread::LoadAbilityLibrary scanDir %{public}s not exits", libraryPath.c_str());
HILOG_ERROR("MainThread::LoadAbilityLibrary scanDir %{public}s not exits", libraryPath.c_str());
}
}
if (fileEntries_.empty()) {
HILOG_INFO("No ability library");
HILOG_ERROR("No ability library");
return;
}
@ -1774,10 +1758,10 @@ void MainThread::LoadAbilityLibrary(const std::vector<std::string> &libraryPaths
resolvedPath, dlerror());
exit(-1);
}
HILOG_INFO("MainThread::LoadAbilityLibrary Success to dlopen %{public}s", fileEntry.c_str());
HILOG_DEBUG("MainThread::LoadAbilityLibrary Success to dlopen %{public}s", fileEntry.c_str());
handleAbilityLib_.emplace_back(handleAbilityLib);
}
HILOG_INFO("MainThread::LoadAbilityLibrary called end.");
HILOG_DEBUG("MainThread::LoadAbilityLibrary called success.");
#endif // ABILITY_LIBRARY_LOADER
}
@ -1840,7 +1824,7 @@ bool MainThread::ScanDir(const std::string &dirPath, std::vector<std::string> &f
}
if (closedir(dirp) == -1) {
HILOG_WARN("close dir fail");
HILOG_ERROR("close dir fail");
}
return true;
}
@ -1868,7 +1852,7 @@ bool MainThread::CheckFileType(const std::string &fileName, const std::string &e
auto position = fileName.rfind('.');
if (position == std::string::npos) {
HILOG_WARN("filename no extension name");
HILOG_ERROR("filename no extension name");
return false;
}

67
frameworks/native/appkit/app/ohos_application.cpp
View File

@ -47,7 +47,7 @@ OHOSApplication::~OHOSApplication() = default;
void OHOSApplication::DispatchAbilitySavedState(const PacMap &outState)
{
HILOG_INFO("OHOSApplication::dispatchAbilitySavedState: called");
HILOG_DEBUG("OHOSApplication::dispatchAbilitySavedState: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilitySaveState(outState);
@ -62,13 +62,12 @@ void OHOSApplication::DispatchAbilitySavedState(const PacMap &outState)
*/
void OHOSApplication::OnForeground()
{
HILOG_INFO("NotifyApplicationState::OnForeground begin");
if (runtime_ == nullptr) {
HILOG_INFO("NotifyApplicationState, runtime_ is nullptr");
HILOG_ERROR("NotifyApplicationState, runtime_ is nullptr");
return;
}
runtime_->NotifyApplicationState(false);
HILOG_INFO("NotifyApplicationState::OnForeground end");
HILOG_DEBUG("NotifyApplicationState::OnForeground end");
}
/**
@ -78,13 +77,12 @@ void OHOSApplication::OnForeground()
*/
void OHOSApplication::OnBackground()
{
HILOG_INFO("NotifyApplicationState::OnBackground begin");
if (runtime_ == nullptr) {
HILOG_INFO("NotifyApplicationState, runtime_ is nullptr");
HILOG_ERROR("NotifyApplicationState, runtime_ is nullptr");
return;
}
runtime_->NotifyApplicationState(true);
HILOG_INFO("NotifyApplicationState::OnBackground end");
HILOG_DEBUG("NotifyApplicationState::OnBackground end");
}
void OHOSApplication::DumpApplication()
@ -138,13 +136,12 @@ void OHOSApplication::DumpApplication()
*/
void OHOSApplication::SetRuntime(std::unique_ptr<AbilityRuntime::Runtime>&& runtime)
{
HILOG_INFO("OHOSApplication::SetRuntime begin");
if (runtime == nullptr) {
HILOG_ERROR("OHOSApplication::SetRuntime failed, runtime is empty");
return;
}
runtime_ = std::move(runtime);
HILOG_INFO("OHOSApplication::SetRuntime end");
HILOG_DEBUG("OHOSApplication::SetRuntime end");
}
/**
@ -155,7 +152,7 @@ void OHOSApplication::SetRuntime(std::unique_ptr<AbilityRuntime::Runtime>&& runt
void OHOSApplication::SetApplicationContext(
const std::shared_ptr<AbilityRuntime::ApplicationContext> &abilityRuntimeContext)
{
HILOG_INFO("OHOSApplication::SetApplicationContext");
HILOG_DEBUG("OHOSApplication::SetApplicationContext");
if (abilityRuntimeContext == nullptr) {
HILOG_ERROR("OHOSApplication::SetApplicationContext failed, context is empty");
return;
@ -171,7 +168,7 @@ void OHOSApplication::SetApplicationContext(
*/
void OHOSApplication::SetAbilityRecordMgr(const std::shared_ptr<AbilityRecordMgr> &abilityRecordMgr)
{
HILOG_INFO("OHOSApplication::SetAbilityRecordMgr");
HILOG_DEBUG("OHOSApplication::SetAbilityRecordMgr");
if (abilityRecordMgr == nullptr) {
HILOG_ERROR("ContextDeal::SetAbilityRecordMgr failed, abilityRecordMgr is nullptr");
return;
@ -187,10 +184,10 @@ void OHOSApplication::SetAbilityRecordMgr(const std::shared_ptr<AbilityRecordMgr
*/
void OHOSApplication::RegisterAbilityLifecycleCallbacks(const std::shared_ptr<AbilityLifecycleCallbacks> &callBack)
{
HILOG_INFO("OHOSApplication::RegisterAbilityLifecycleCallbacks: called");
HILOG_DEBUG("OHOSApplication::RegisterAbilityLifecycleCallbacks: called");
if (callBack == nullptr) {
HILOG_INFO("OHOSApplication::RegisterAbilityLifecycleCallbacks: observer is null");
HILOG_ERROR("OHOSApplication::RegisterAbilityLifecycleCallbacks: observer is null");
return;
}
@ -205,10 +202,10 @@ void OHOSApplication::RegisterAbilityLifecycleCallbacks(const std::shared_ptr<Ab
*/
void OHOSApplication::UnregisterAbilityLifecycleCallbacks(const std::shared_ptr<AbilityLifecycleCallbacks> &callBack)
{
HILOG_INFO("OHOSApplication::UnregisterAbilityLifecycleCallbacks: called");
HILOG_DEBUG("OHOSApplication::UnregisterAbilityLifecycleCallbacks: called");
if (callBack == nullptr) {
HILOG_INFO("OHOSApplication::UnregisterAbilityLifecycleCallbacks: observer is null");
HILOG_ERROR("OHOSApplication::UnregisterAbilityLifecycleCallbacks: observer is null");
return;
}
@ -228,7 +225,7 @@ void OHOSApplication::OnAbilityStart(const std::shared_ptr<Ability> &ability)
return;
}
HILOG_INFO("OHOSApplication::OnAbilityStart: called");
HILOG_DEBUG("OHOSApplication::OnAbilityStart: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityStart(ability);
@ -249,7 +246,7 @@ void OHOSApplication::OnAbilityInactive(const std::shared_ptr<Ability> &ability)
return;
}
HILOG_INFO("OHOSApplication::OnAbilityInactive: called");
HILOG_DEBUG("OHOSApplication::OnAbilityInactive: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityInactive(ability);
@ -270,7 +267,7 @@ void OHOSApplication::OnAbilityBackground(const std::shared_ptr<Ability> &abilit
return;
}
HILOG_INFO("OHOSApplication::OnAbilityBackground: called");
HILOG_DEBUG("OHOSApplication::OnAbilityBackground: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityBackground(ability);
@ -291,7 +288,7 @@ void OHOSApplication::OnAbilityForeground(const std::shared_ptr<Ability> &abilit
return;
}
HILOG_INFO("OHOSApplication::OnAbilityForeground: called");
HILOG_DEBUG("OHOSApplication::OnAbilityForeground: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityForeground(ability);
@ -312,7 +309,7 @@ void OHOSApplication::OnAbilityActive(const std::shared_ptr<Ability> &ability)
return;
}
HILOG_INFO("OHOSApplication::OnAbilityActive: called");
HILOG_DEBUG("OHOSApplication::OnAbilityActive: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityActive(ability);
@ -333,7 +330,7 @@ void OHOSApplication::OnAbilityStop(const std::shared_ptr<Ability> &ability)
return;
}
HILOG_INFO("OHOSApplication::OnAbilityStop: called");
HILOG_DEBUG("OHOSApplication::OnAbilityStop: called");
for (auto callback : abilityLifecycleCallbacks_) {
if (callback != nullptr) {
callback->OnAbilityStop(ability);
@ -349,10 +346,10 @@ void OHOSApplication::OnAbilityStop(const std::shared_ptr<Ability> &ability)
*/
void OHOSApplication::RegisterElementsCallbacks(const std::shared_ptr<ElementsCallback> &callback)
{
HILOG_INFO("OHOSApplication::RegisterElementsCallbacks: called");
HILOG_DEBUG("OHOSApplication::RegisterElementsCallbacks: called");
if (callback == nullptr) {
HILOG_INFO("OHOSApplication::RegisterElementsCallbacks: observer is null");
HILOG_ERROR("OHOSApplication::RegisterElementsCallbacks: observer is null");
return;
}
@ -367,10 +364,10 @@ void OHOSApplication::RegisterElementsCallbacks(const std::shared_ptr<ElementsCa
*/
void OHOSApplication::UnregisterElementsCallbacks(const std::shared_ptr<ElementsCallback> &callback)
{
HILOG_INFO("OHOSApplication::UnregisterElementsCallbacks: called");
HILOG_DEBUG("OHOSApplication::UnregisterElementsCallbacks: called");
if (callback == nullptr) {
HILOG_INFO("OHOSApplication::UnregisterElementsCallbacks: observer is null");
HILOG_ERROR("OHOSApplication::UnregisterElementsCallbacks: observer is null");
return;
}
@ -385,9 +382,9 @@ void OHOSApplication::UnregisterElementsCallbacks(const std::shared_ptr<Elements
*/
void OHOSApplication::OnConfigurationUpdated(const Configuration &config)
{
HILOG_INFO("OHOSApplication::OnConfigurationUpdated: called");
HILOG_DEBUG("OHOSApplication::OnConfigurationUpdated: called");
if (!abilityRecordMgr_ || !configuration_) {
HILOG_INFO("abilityRecordMgr_ or configuration_ is null");
HILOG_ERROR("abilityRecordMgr_ or configuration_ is null");
return;
}
@ -397,7 +394,7 @@ void OHOSApplication::OnConfigurationUpdated(const Configuration &config)
configuration_->Merge(changeKeyV, config);
// Notify all abilities
HILOG_INFO(
HILOG_DEBUG(
"Number of ability to be notified : [%{public}d]", static_cast<int>(abilityRecordMgr_->GetRecordCount()));
for (const auto &abilityToken : abilityRecordMgr_->GetAllTokens()) {
auto abilityRecord = abilityRecordMgr_->GetAbilityItem(abilityToken);
@ -407,7 +404,7 @@ void OHOSApplication::OnConfigurationUpdated(const Configuration &config)
}
// Notify AbilityStage
HILOG_INFO("Number of abilityStage to be notified : [%{public}zu]", abilityStages_.size());
HILOG_DEBUG("Number of abilityStage to be notified : [%{public}zu]", abilityStages_.size());
for (auto it = abilityStages_.begin(); it != abilityStages_.end(); it++) {
auto abilityStage = it->second;
if (abilityStage) {
@ -434,7 +431,7 @@ void OHOSApplication::OnConfigurationUpdated(const Configuration &config)
*/
void OHOSApplication::OnMemoryLevel(int level)
{
HILOG_INFO("OHOSApplication::OnMemoryLevel: called");
HILOG_DEBUG("OHOSApplication::OnMemoryLevel: called");
for (auto callback : elementsCallbacks_) {
if (callback != nullptr) {
callback->OnMemoryLevel(level);
@ -449,7 +446,7 @@ void OHOSApplication::OnMemoryLevel(int level)
*/
void OHOSApplication::OnStart()
{
HILOG_INFO("OnStart called.");
HILOG_DEBUG("OnStart called.");
}
/**
@ -459,7 +456,7 @@ void OHOSApplication::OnStart()
*/
void OHOSApplication::OnTerminate()
{
HILOG_INFO("OHOSApplication::OnTerminate: called");
HILOG_DEBUG("OHOSApplication::OnTerminate: called");
}
/**
@ -503,7 +500,7 @@ std::shared_ptr<AbilityRuntime::Context> OHOSApplication::AddAbilityStage(
abilityStage->Init(stageContext);
Want want;
if (abilityRecord->GetWant()) {
HILOG_INFO("want is ok, transport to abilityStage");
HILOG_DEBUG("want is ok, transport to abilityStage");
want = *(abilityRecord->GetWant());
}
abilityStage->OnCreate(want);
@ -522,7 +519,7 @@ std::shared_ptr<AbilityRuntime::Context> OHOSApplication::AddAbilityStage(
bool OHOSApplication::AddAbilityStage(const AppExecFwk::HapModuleInfo &hapModuleInfo)
{
HILOG_INFO("OHOSApplication::AddAbilityStage");
HILOG_DEBUG("OHOSApplication::AddAbilityStage");
if (abilityRuntimeContext_ == nullptr) {
HILOG_ERROR("OHOSApplication::AddAbilityStage abilityRuntimeContext_ is nullptr.");
return false;
@ -597,7 +594,7 @@ void OHOSApplication::SetConfiguration(const Configuration &config)
void OHOSApplication::ScheduleAcceptWant(const AAFwk::Want &want, const std::string &moduleName, std::string &flag)
{
HILOG_INFO("OHOSApplication::ScheduleAcceptWant: called");
HILOG_DEBUG("OHOSApplication::ScheduleAcceptWant: called");
auto iter = abilityStages_.find(moduleName);
if (iter != abilityStages_.end()) {
auto abilityStage = iter->second;

4
frameworks/native/appkit/app/watchdog.cpp
View File

@ -62,13 +62,13 @@ void WatchDog::Init(const std::shared_ptr<EventHandler> &mainHandler, const std:
WatchDog::currentHandler_ = watchDogHandler;
if (watchDogThread_ == nullptr) {
watchDogThread_ = std::make_shared<std::thread>(&WatchDog::Timer, this);
HILOG_INFO("Watchdog is running!");
HILOG_DEBUG("Watchdog is running!");
}
}
void WatchDog::Stop()
{
HILOG_INFO("Watchdog is stop !");
HILOG_DEBUG("Watchdog is stop !");
stopWatchDog_.store(true);
cvWatchDog_.notify_all();