openharmony/ability_ability_runtime
1
0
Fork 0
mirror of https://github.com/openharmony/ability_ability_runtime.git synced 2026-08-24 22:21:36 -04:00
Code Issues Packages Projects Releases Wiki Activity

modify native& ability_controller_proxy.cpp

Browse Source 
Signed-off-by: xinking129 <xinxin13@huawei.com>
This commit is contained in:
xinking129
2024-03-23 14:25:17 +08:00
parent b11c4b76d9
commit 4e20afdd39
18 changed files with 772 additions and 728 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frameworks/native/ability/native/ability.cpp
+312 -303
View File
File diff suppressed because it is too large Load Diff
frameworks/native/ability/native/ability_context.cpp
+50 -45
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -19,6 +19,7 @@
#include "accesstoken_kit.h"
#include "authorization_result.h"
#include "bundle_constants.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "iservice_registry.h"
#include "os_account_manager_wrapper.h"
@@ -47,28 +48,29 @@ const std::string CALLBACK_KEY = "ohos.ability.params.callback";
ErrCode AbilityContext::StartAbility(const AAFwk::Want &want, int requestCode)
{
HILOG_DEBUG("AbilityContext::StartAbility called, requestCode = %{public}d", requestCode);
TAG_LOGD(AAFwkTag::CONTEXT, "AbilityContext::StartAbility called, requestCode = %{public}d", requestCode);
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (type != AppExecFwk::AbilityType::PAGE && type != AppExecFwk::AbilityType::SERVICE) {
HILOG_ERROR("AbilityContext::StartAbility AbilityType = %{public}d", type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::StartAbility AbilityType = %{public}d", type);
return ERR_INVALID_VALUE;
}
ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, token_, requestCode);
HILOG_DEBUG("%{public}s. End calling ams->StartAbility. ret=%{public}d", __func__, err);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s. End calling ability_manager->StartAbility. ret=%{public}d", __func__, err);
return err;
}
ErrCode AbilityContext::StartAbility(const Want &want, int requestCode, const AbilityStartSetting &abilityStartSetting)
{
HILOG_DEBUG("AbilityContext::StartAbility with start setting called, requestCode = %{public}d", requestCode);
TAG_LOGD(AAFwkTag::CONTEXT, "AbilityContext::StartAbility with start setting called, requestCode = %{public}d",
requestCode);
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (type != AppExecFwk::AbilityType::PAGE && type != AppExecFwk::AbilityType::SERVICE) {
HILOG_ERROR("AbilityContext::StartAbility AbilityType = %{public}d", type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::StartAbility AbilityType = %{public}d", type);
return ERR_INVALID_VALUE;
}
ErrCode err =
AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, abilityStartSetting, token_, requestCode);
HILOG_DEBUG("%{public}s. End calling ams->StartAbility. ret=%{public}d", __func__, err);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s. End calling ability_manager->StartAbility. ret=%{public}d", __func__, err);
return err;
}
@@ -76,43 +78,45 @@ ErrCode AbilityContext::TerminateAbility()
{
std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
if (info == nullptr) {
HILOG_ERROR("AbilityContext::TerminateAbility info == nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::TerminateAbility info == nullptr");
return ERR_NULL_OBJECT;
}
ErrCode err = ERR_OK;
switch (info->type) {
case AppExecFwk::AbilityType::PAGE:
HILOG_DEBUG("Terminate ability begin, type is page, ability is %{public}s.", info->name.c_str());
TAG_LOGD(AAFwkTag::CONTEXT, "Terminate ability begin, type is page, ability is %{public}s.",
info->name.c_str());
if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
auto sessionToken = GetSessionToken();
if (sessionToken == nullptr) {
HILOG_ERROR("sessionToken is nullptr.");
TAG_LOGE(AAFwkTag::CONTEXT, "sessionToken is nullptr.");
return ERR_INVALID_VALUE;
}
sptr<AAFwk::SessionInfo> sessionInfo = new AAFwk::SessionInfo();
sessionInfo->want = resultWant_;
sessionInfo->resultCode = resultCode_;
HILOG_INFO("FA TerminateAbility resultCode is %{public}d", sessionInfo->resultCode);
TAG_LOGI(AAFwkTag::CONTEXT, "FA TerminateAbility resultCode is %{public}d", sessionInfo->resultCode);
auto ifaceSessionToken = iface_cast<Rosen::ISession>(sessionToken);
auto err = ifaceSessionToken->TerminateSession(sessionInfo);
HILOG_INFO("FA TerminateAbility. ret=%{public}d", err);
TAG_LOGI(AAFwkTag::CONTEXT, "FA TerminateAbility. ret=%{public}d", err);
return static_cast<int32_t>(err);
} else {
err = AAFwk::AbilityManagerClient::GetInstance()->TerminateAbility(token_, resultCode_, &resultWant_);
}
break;
case AppExecFwk::AbilityType::SERVICE:
HILOG_DEBUG("Terminate ability begin, type is service, ability is %{public}s.", info->name.c_str());
TAG_LOGD(AAFwkTag::CONTEXT, "Terminate ability begin, type is service, ability is %{public}s.",
info->name.c_str());
err = AAFwk::AbilityManagerClient::GetInstance()->TerminateAbility(token_, -1, nullptr);
break;
default:
HILOG_ERROR("AbilityContext::TerminateAbility info type error is %{public}d", info->type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::TerminateAbility info type error is %{public}d", info->type);
break;
}
if (err != ERR_OK) {
HILOG_ERROR("AbilityContext::TerminateAbility is failed %{public}d", err);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::TerminateAbility is failed %{public}d", err);
}
return err;
}
@@ -124,10 +128,10 @@ std::string AbilityContext::GetCallingBundle()
std::shared_ptr<ElementName> AbilityContext::GetElementName()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s begin.", __func__);
std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
if (info == nullptr) {
HILOG_ERROR("AbilityContext::GetElementName info == nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::GetElementName info == nullptr");
return nullptr;
}
@@ -136,19 +140,19 @@ std::shared_ptr<ElementName> AbilityContext::GetElementName()
elementName->SetBundleName(info->bundleName);
elementName->SetDeviceID(info->deviceId);
elementName->SetModuleName(info->moduleName);
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end.", __func__);
return elementName;
}
std::shared_ptr<ElementName> AbilityContext::GetCallingAbility()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s begin.", __func__);
std::shared_ptr<ElementName> elementName = std::make_shared<ElementName>();
elementName->SetAbilityName(callingAbilityName_);
elementName->SetBundleName(callingBundleName_);
elementName->SetDeviceID(callingDeviceId_);
elementName->SetModuleName(callingModuleName_);
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end.", __func__);
return elementName;
}
@@ -159,24 +163,24 @@ bool AbilityContext::ConnectAbility(const Want &want, const sptr<AAFwk::IAbility
std::shared_ptr<AbilityInfo> abilityInfo = GetAbilityInfo();
if (abilityInfo == nullptr) {
HILOG_ERROR("AbilityContext::ConnectAbility info == nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::ConnectAbility info == nullptr");
return false;
}
HILOG_INFO("Connect ability begin, ability:%{public}s.", abilityInfo->name.c_str());
TAG_LOGI(AAFwkTag::CONTEXT, "Connect ability begin, ability:%{public}s.", abilityInfo->name.c_str());
if (type != AppExecFwk::AbilityType::PAGE && type != AppExecFwk::AbilityType::SERVICE) {
HILOG_ERROR("AbilityContext::ConnectAbility AbilityType = %{public}d", type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::ConnectAbility AbilityType = %{public}d", type);
return false;
}
ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->ConnectAbility(want, conn, token_);
HILOG_DEBUG("%{public}s end ConnectAbility, ret=%{public}d", __func__, ret);
TAG_LOGD(AAFwkTag::CONTEXT, "%{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);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::ConnectAbility ErrorCode = %{public}d", ret);
}
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end.", __func__);
return value;
}
@@ -184,33 +188,34 @@ 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());
TAG_LOGI(AAFwkTag::CONTEXT, "Disconnect ability begin, caller:%{public}s.",
info == nullptr ? "" : info->name.c_str());
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (type != AppExecFwk::AbilityType::PAGE && type != AppExecFwk::AbilityType::SERVICE) {
HILOG_ERROR("AbilityContext::DisconnectAbility AbilityType = %{public}d", type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::DisconnectAbility AbilityType = %{public}d", type);
return ERR_INVALID_VALUE;
}
ErrCode ret = AAFwk::AbilityManagerClient::GetInstance()->DisconnectAbility(conn);
if (ret != ERR_OK) {
HILOG_ERROR("AbilityContext::DisconnectAbility error, ret=%{public}d.", ret);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::DisconnectAbility error, ret=%{public}d.", ret);
}
return ret;
}
bool AbilityContext::StopAbility(const AAFwk::Want &want)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s begin.", __func__);
AppExecFwk::AbilityType type = GetAbilityInfoType();
if (type != AppExecFwk::AbilityType::PAGE && type != AppExecFwk::AbilityType::SERVICE) {
HILOG_ERROR("AbilityContext::StopAbility AbilityType = %{public}d", type);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::StopAbility AbilityType = %{public}d", type);
return false;
}
ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StopServiceAbility(want, token_);
if (err != ERR_OK) {
HILOG_ERROR("AbilityContext::StopAbility is failed %{public}d", err);
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::StopAbility is failed %{public}d", err);
return false;
}
@@ -226,7 +231,7 @@ AppExecFwk::AbilityType AbilityContext::GetAbilityInfoType()
{
std::shared_ptr<AbilityInfo> info = GetAbilityInfo();
if (info == nullptr) {
HILOG_ERROR("AbilityContext::GetAbilityInfoType info == nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::GetAbilityInfoType info == nullptr");
return AppExecFwk::AbilityType::UNKNOWN;
}
@@ -237,15 +242,15 @@ std::shared_ptr<Global::Resource::ResourceManager> AbilityContext::GetResourceMa
{
std::shared_ptr<Context> appContext = GetApplicationContext();
if (appContext == nullptr) {
HILOG_ERROR("AbilityContext::GetResourceManager appContext is nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::GetResourceManager appContext is nullptr");
return nullptr;
}
HILOG_DEBUG("%{public}s begin appContext->GetResourceManager.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s begin appContext->GetResourceManager.", __func__);
std::shared_ptr<Global::Resource::ResourceManager> resourceManager = appContext->GetResourceManager();
HILOG_DEBUG("%{public}s end appContext->GetResourceManager.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end appContext->GetResourceManager.", __func__);
if (resourceManager == nullptr) {
HILOG_ERROR("AbilityContext::GetResourceManager resourceManager is nullptr");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::GetResourceManager resourceManager is nullptr");
return nullptr;
}
return resourceManager;
@@ -253,13 +258,13 @@ 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",
TAG_LOGI(AAFwkTag::CONTEXT, "%{public}s begin. permission=%{public}s, pid=%{public}d, uid=%{public}d",
__func__,
permission.c_str(),
pid,
uid);
ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->VerifyPermission(permission, pid, uid);
HILOG_DEBUG("End calling VerifyPermission. ret=%{public}d", err);
TAG_LOGD(AAFwkTag::CONTEXT, "End calling VerifyPermission. ret=%{public}d", err);
if (err != ERR_OK) {
return AppExecFwk::Constants::PERMISSION_NOT_GRANTED;
}
@@ -271,18 +276,18 @@ void AbilityContext::GetPermissionDes(const std::string &permissionName, std::st
Security::AccessToken::PermissionDef permissionDef;
int32_t ret = Security::AccessToken::AccessTokenKit::GetDefPermission(permissionName, permissionDef);
if (ret == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) {
HILOG_DEBUG("GetPermissionDes %{public}s: RET_SUCCESS", permissionName.c_str());
TAG_LOGD(AAFwkTag::CONTEXT, "GetPermissionDes %{public}s: RET_SUCCESS", permissionName.c_str());
des = permissionDef.description;
}
HILOG_DEBUG("%{public}s end GetPermissionDef.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end GetPermissionDef.", __func__);
}
void AbilityContext::RequestPermissionsFromUser(std::vector<std::string> &permissions,
std::vector<int> &permissionsState, PermissionRequestTask &&task)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s begin.", __func__);
if (permissions.size() == 0) {
HILOG_ERROR("AbilityContext::RequestPermissionsFromUser permissions is empty");
TAG_LOGE(AAFwkTag::CONTEXT, "AbilityContext::RequestPermissionsFromUser permissions is empty");
return;
}
@@ -294,7 +299,7 @@ void AbilityContext::RequestPermissionsFromUser(std::vector<std::string> &permis
sptr<IRemoteObject> remoteObject = new AbilityRuntime::AuthorizationResult(std::move(task));
want.SetParam(CALLBACK_KEY, remoteObject);
StartAbility(want, -1);
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end.", __func__);
}
void AbilityContext::SetCallingContext(const std::string &deviceId, const std::string &bundleName,
@@ -311,7 +316,7 @@ void AbilityContext::StartAbilities(const std::vector<AAFwk::Want> &wants)
for (auto want : wants) {
StartAbility(want, ABILITY_CONTEXT_DEFAULT_REQUEST_CODE);
}
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::CONTEXT, "%{public}s end.", __func__);
}
sptr<IRemoteObject> AbilityContext::GetSessionToken()
frameworks/native/ability/native/ability_impl.cpp
+118 -113
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -19,6 +19,7 @@
#include "ability_transaction_callback_info.h"
#include "data_ability_predicates.h"
#include "freeze_util.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "hitrace_meter.h"
#include "ohos_application.h"
@@ -41,11 +42,12 @@ void AbilityImpl::Init(const std::shared_ptr<OHOSApplication> &application,
const sptr<IRemoteObject> &token)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_DEBUG("AbilityImpl::init begin");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::init begin");
if ((token == nullptr) || (application == nullptr) || (handler == nullptr) || (record == nullptr) ||
ability == nullptr) {
HILOG_ERROR("AbilityImpl::init failed, token is nullptr, application is nullptr, handler is nullptr, record is "
"nullptr, ability is nullptr");
TAG_LOGE(AAFwkTag::ABILITY,
"AbilityImpl::init failed, token is nullptr, application is nullptr, handler is nullptr, record is "
"nullptr, ability is nullptr");
return;
}
@@ -62,15 +64,15 @@ void AbilityImpl::Init(const std::shared_ptr<OHOSApplication> &application,
ability_->Init(record->GetAbilityInfo(), application, handler, token);
lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
abilityLifecycleCallbacks_ = application;
HILOG_DEBUG("AbilityImpl::init end");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::init end");
}
void AbilityImpl::Start(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Start ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Start ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
#ifdef SUPPORT_GRAPHICS
@@ -84,7 +86,7 @@ void AbilityImpl::Start(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
ability_->HandleCreateAsRecovery(want);
}
#endif
HILOG_DEBUG("AbilityImpl::Start");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Start");
ability_->OnStart(want, sessionInfo);
#ifdef SUPPORT_GRAPHICS
if ((ability_->GetAbilityInfo()->type == AppExecFwk::AbilityType::PAGE) &&
@@ -101,27 +103,27 @@ void AbilityImpl::Start(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
}
#endif
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::Stop()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
ability_->OnStop();
StopCallback();
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::Stop(bool &isAsyncCallback)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
isAsyncCallback = false;
return;
}
@@ -137,7 +139,7 @@ void AbilityImpl::Stop(bool &isAsyncCallback)
auto asyncCallback = [abilityImplWeakPtr = weakPtr, state = ABILITY_STATE_INITIAL]() {
auto abilityImpl = abilityImplWeakPtr.lock();
if (abilityImpl == nullptr) {
HILOG_ERROR("abilityImpl is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "abilityImpl is nullptr.");
return;
}
abilityImpl->StopCallback();
@@ -151,13 +153,13 @@ void AbilityImpl::Stop(bool &isAsyncCallback)
AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
}
// else: callbackInfo will be destroyed after the async callback
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::StopCallback()
{
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Stop ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
#ifdef SUPPORT_GRAPHICS
@@ -175,9 +177,9 @@ void AbilityImpl::StopCallback()
void AbilityImpl::Active()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Active ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Active ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
@@ -189,14 +191,14 @@ void AbilityImpl::Active()
}
#endif
lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::Inactive()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Inactive ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Inactive ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
@@ -208,15 +210,15 @@ void AbilityImpl::Inactive()
}
#endif
lifecycleState_ = AAFwk::ABILITY_STATE_INACTIVE;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
int32_t AbilityImpl::Share(WantParams &wantParam)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::OnShare ability_ is nullptr ");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::OnShare ability_ is nullptr ");
return ERR_INVALID_VALUE;
}
return ability_->OnShare(wantParam);
@@ -229,27 +231,28 @@ bool AbilityImpl::IsStageBasedModel() const
void AbilityImpl::DispatchSaveAbilityState()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::DispatchSaveAbilityState ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY,
"AbilityImpl::DispatchSaveAbilityState ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
needSaveDate_ = true;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::DispatchRestoreAbilityState(const PacMap &inState)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::DispatchRestoreAbilityState ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::DispatchRestoreAbilityState ability_ is nullptr");
return;
}
hasSaveData_ = true;
restoreData_ = inState;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState,
@@ -264,14 +267,14 @@ void AbilityImpl::AbilityTransactionCallback(const AAFwk::AbilityLifeCycleState
sptr<IRemoteObject> AbilityImpl::ConnectAbility(const Want &want)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::ConnectAbility ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::ConnectAbility ability_ is nullptr");
return nullptr;
}
sptr<IRemoteObject> object = ability_->OnConnect(want);
lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
return object;
}
@@ -279,34 +282,34 @@ sptr<IRemoteObject> AbilityImpl::ConnectAbility(const Want &want)
void AbilityImpl::DisconnectAbility(const Want &want)
{
if (ability_ == nullptr) {
HILOG_ERROR("Disconnect ability error, ability_ is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "Disconnect ability error, ability_ is nullptr.");
return;
}
HILOG_DEBUG("Disconnect ability begin, ability:%{public}s.", ability_->GetAbilityName().c_str());
TAG_LOGD(AAFwkTag::ABILITY, "Disconnect ability begin, ability:%{public}s.", ability_->GetAbilityName().c_str());
ability_->OnDisconnect(want);
}
void AbilityImpl::CommandAbility(const Want &want, bool restart, int startId)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::CommandAbility ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CommandAbility ability_ is nullptr");
return;
}
ability_->OnCommand(want, restart, startId);
lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
bool AbilityImpl::PrepareTerminateAbility()
{
HILOG_DEBUG("call");
TAG_LOGD(AAFwkTag::ABILITY, "call");
if (ability_ == nullptr) {
HILOG_ERROR("ability_ is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "ability_ is nullptr.");
return false;
}
bool ret = ability_->OnPrepareTerminate();
HILOG_DEBUG("end, ret = %{public}d", ret);
TAG_LOGD(AAFwkTag::ABILITY, "end, ret = %{public}d", ret);
return ret;
}
@@ -317,23 +320,23 @@ int AbilityImpl::GetCurrentState()
void AbilityImpl::SendResult(int requestCode, int resultCode, const Want &resultData)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::SendResult ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::SendResult ability_ is nullptr");
return;
}
ability_->OnAbilityResult(requestCode, resultCode, resultData);
// for api5 FeatureAbility::startAbilityForResult
ability_->OnFeatureAbilityResult(requestCode, resultCode, resultData);
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::NewWant(const Want &want)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::NewWant ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::NewWant ability_ is nullptr");
return;
}
ability_->SetWant(want);
@@ -341,64 +344,64 @@ void AbilityImpl::NewWant(const Want &want)
#ifdef SUPPORT_GRAPHICS
ability_->ContinuationRestore(want);
#endif
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
std::vector<std::string> AbilityImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
{
HILOG_DEBUG("AbilityImpl::GetFileTypes");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::GetFileTypes");
std::vector<std::string> types;
return types;
}
int AbilityImpl::OpenFile(const Uri &uri, const std::string &mode)
{
HILOG_DEBUG("AbilityImpl::OpenFile");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::OpenFile");
return -1;
}
int AbilityImpl::OpenRawFile(const Uri &uri, const std::string &mode)
{
HILOG_DEBUG("AbilityImpl::OpenRawFile");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::OpenRawFile");
return -1;
}
int AbilityImpl::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
{
HILOG_DEBUG("AbilityImpl::Insert");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Insert");
return -1;
}
std::shared_ptr<AppExecFwk::PacMap> AbilityImpl::Call(
const Uri &uri, const std::string &method, const std::string &arg, const AppExecFwk::PacMap &pacMap)
{
HILOG_DEBUG("AbilityImpl::Call");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Call");
return nullptr;
}
int AbilityImpl::Update(
const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("AbilityImpl::Update");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Update");
return -1;
}
int AbilityImpl::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("AbilityImpl::Delete");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Delete");
return -1;
}
std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityImpl::Query(
const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("AbilityImpl::Query");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Query");
return nullptr;
}
std::string AbilityImpl::GetType(const Uri &uri)
{
HILOG_DEBUG("AbilityImpl::GetType");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::GetType");
return "";
}
@@ -409,25 +412,25 @@ bool AbilityImpl::Reload(const Uri &uri, const PacMap &extras)
int AbilityImpl::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
{
HILOG_DEBUG("AbilityImpl::BatchInsert");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::BatchInsert");
return -1;
}
void AbilityImpl::SetUriString(const std::string &uri)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::SetUriString ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::SetUriString ability_ is nullptr");
return;
}
ability_->SetUriString(uri);
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::SetLifeCycleStateInfo(const AAFwk::LifeCycleStateInfo &info)
{
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::SetLifeCycleStateInfo ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::SetLifeCycleStateInfo ability_ is nullptr");
return;
}
ability_->SetLifeCycleStateInfo(info);
@@ -435,32 +438,32 @@ void AbilityImpl::SetLifeCycleStateInfo(const AAFwk::LifeCycleStateInfo &info)
bool AbilityImpl::CheckAndRestore()
{
HILOG_DEBUG("AbilityImpl::CheckAndRestore called start");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::CheckAndRestore called start");
if (!hasSaveData_) {
HILOG_ERROR("AbilityImpl::CheckAndRestore hasSaveData_ is false");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CheckAndRestore hasSaveData_ is false");
return false;
}
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::CheckAndRestore ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CheckAndRestore ability_ is nullptr");
return false;
}
ability_->OnRestoreAbilityState(restoreData_);
HILOG_DEBUG("AbilityImpl::CheckAndRestore called end");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::CheckAndRestore called end");
return true;
}
bool AbilityImpl::CheckAndSave()
{
HILOG_DEBUG("AbilityImpl::CheckAndSave called start");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::CheckAndSave called start");
if (!needSaveDate_) {
HILOG_ERROR("AbilityImpl::CheckAndSave needSaveDate_ is false");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CheckAndSave needSaveDate_ is false");
return false;
}
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::CheckAndSave ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CheckAndSave ability_ is nullptr");
return false;
}
@@ -468,7 +471,7 @@ bool AbilityImpl::CheckAndSave()
needSaveDate_ = false;
HILOG_DEBUG("AbilityImpl::CheckAndSave called end");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::CheckAndSave called end");
return true;
}
@@ -487,36 +490,36 @@ void AbilityImpl::SetCallingContext(const std::string &deviceId, const std::stri
Uri AbilityImpl::NormalizeUri(const Uri &uri)
{
HILOG_DEBUG("AbilityImpl::NormalizeUri");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::NormalizeUri");
return uri;
}
Uri AbilityImpl::DenormalizeUri(const Uri &uri)
{
HILOG_DEBUG("AbilityImpl::DenormalizeUri");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DenormalizeUri");
return uri;
}
void AbilityImpl::ScheduleUpdateConfiguration(const Configuration &config)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::ScheduleUpdateConfiguration ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::ScheduleUpdateConfiguration ability_ is nullptr");
return;
}
if (lifecycleState_ != AAFwk::ABILITY_STATE_INITIAL) {
HILOG_INFO("ability name: [%{public}s]", ability_->GetAbilityName().c_str());
TAG_LOGI(AAFwkTag::ABILITY, "ability name: [%{public}s]", ability_->GetAbilityName().c_str());
ability_->OnConfigurationUpdatedNotify(config);
}
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
std::shared_ptr<AbilityPostEventTimeout> AbilityImpl::CreatePostEventTimeouter(std::string taskstr)
{
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::CreatePostEventTimeouter ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::CreatePostEventTimeouter ability_ is nullptr");
return nullptr;
}
@@ -526,7 +529,7 @@ std::shared_ptr<AbilityPostEventTimeout> AbilityImpl::CreatePostEventTimeouter(s
std::vector<std::shared_ptr<DataAbilityResult>> AbilityImpl::ExecuteBatch(
const std::vector<std::shared_ptr<DataAbilityOperation>> &operations)
{
HILOG_DEBUG("AbilityImpl::ExecuteBatch");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::ExecuteBatch");
std::vector<std::shared_ptr<DataAbilityResult>> results;
return results;
}
@@ -534,7 +537,7 @@ std::vector<std::shared_ptr<DataAbilityResult>> AbilityImpl::ExecuteBatch(
void AbilityImpl::ContinueAbility(const std::string& deviceId, uint32_t versionCode)
{
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::ContinueAbility ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::ContinueAbility ability_ is nullptr");
return;
}
ability_->ContinueAbilityWithStack(deviceId, versionCode);
@@ -543,7 +546,7 @@ void AbilityImpl::ContinueAbility(const std::string& deviceId, uint32_t versionC
void AbilityImpl::NotifyContinuationResult(int32_t result)
{
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::NotifyContinuationResult ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::NotifyContinuationResult ability_ is nullptr");
return;
}
ability_->OnCompleteContinuation(result);
@@ -552,7 +555,7 @@ void AbilityImpl::NotifyContinuationResult(int32_t result)
void AbilityImpl::NotifyMemoryLevel(int32_t level)
{
if (ability_ == nullptr) {
HILOG_ERROR("AbilityImpl::NotifyMemoryLevel ability_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::NotifyMemoryLevel ability_ is nullptr");
return;
}
ability_->OnMemoryLevel(level);
@@ -578,10 +581,12 @@ void AbilityImpl::AfterFocusedCommon(bool isFocused)
}
if (!impl->ability_ || !impl->ability_->GetAbilityInfo()) {
HILOG_WARN("AbilityImpl::%{public}s failed", focuseMode ? "AfterFocused" : "AfterUnFocused");
TAG_LOGW(AAFwkTag::ABILITY,
"AbilityImpl::%{public}s failed", focuseMode ? "AfterFocused" : "AfterUnFocused");
return;
}
HILOG_INFO("isStageBasedModel: %{public}d", impl->ability_->GetAbilityInfo()->isStageBasedModel);
TAG_LOGI(AAFwkTag::ABILITY, "isStageBasedModel: %{public}d",
impl->ability_->GetAbilityInfo()->isStageBasedModel);
if (impl->ability_->GetAbilityInfo()->isStageBasedModel) {
auto abilityContext = impl->ability_->GetAbilityContext();
@@ -602,7 +607,7 @@ void AbilityImpl::AfterFocusedCommon(bool isFocused)
}
if (impl->ability_->GetWant() == nullptr) {
HILOG_WARN("want is nullptr.");
TAG_LOGW(AAFwkTag::ABILITY, "want is nullptr.");
return;
}
auto info = impl->ability_->GetLifeCycleStateInfo();
@@ -618,16 +623,16 @@ void AbilityImpl::AfterFocusedCommon(bool isFocused)
if (handler_) {
handler_->PostTask(task, "AbilityImpl:AfterFocusedCommon");
}
HILOG_DEBUG("end.");
TAG_LOGD(AAFwkTag::ABILITY, "end.");
}
void AbilityImpl::WindowLifeCycleImpl::AfterForeground()
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_INFO("Lifecycle: Call.");
TAG_LOGI(AAFwkTag::ABILITY, "Lifecycle: Call.");
auto owner = owner_.lock();
if (owner == nullptr || !owner->IsStageBasedModel()) {
HILOG_ERROR("Not stage mode ability or abilityImpl is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "Not stage mode ability or abilityImpl is nullptr.");
return;
}
FreezeUtil::LifecycleFlow flow = { token_, FreezeUtil::TimeoutState::FOREGROUND };
@@ -642,13 +647,13 @@ void AbilityImpl::WindowLifeCycleImpl::AfterForeground()
owner->notifyForegroundByAbility_ = false;
needNotifyAMS = true;
} else {
HILOG_DEBUG("Notify foreground by window, but client's foreground is running.");
TAG_LOGD(AAFwkTag::ABILITY, "Notify foreground by window, but client's foreground is running.");
owner->notifyForegroundByWindow_ = true;
}
}
if (needNotifyAMS) {
HILOG_INFO("Lifecycle: window notify ability manager service.");
TAG_LOGI(AAFwkTag::ABILITY, "Lifecycle: window notify ability manager service.");
PacMap restoreData;
auto ret = AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_,
AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW, restoreData);
@@ -663,7 +668,7 @@ void AbilityImpl::WindowLifeCycleImpl::AfterBackground()
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
auto owner = owner_.lock();
if (owner && !owner->IsStageBasedModel()) {
HILOG_WARN("Not stage.");
TAG_LOGW(AAFwkTag::ABILITY, "Not stage.");
return;
}
FreezeUtil::LifecycleFlow flow = { token_, FreezeUtil::TimeoutState::BACKGROUND };
@@ -671,7 +676,7 @@ void AbilityImpl::WindowLifeCycleImpl::AfterBackground()
"; AbilityImpl::WindowLifeCycleImpl::AfterBackground; the background lifecycle.";
FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry);
HILOG_INFO("Lifecycle: window after background.");
TAG_LOGI(AAFwkTag::ABILITY, "Lifecycle: window after background.");
PacMap restoreData;
auto ret = AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_,
AbilityLifeCycleState::ABILITY_STATE_BACKGROUND_NEW, restoreData);
@@ -682,31 +687,31 @@ void AbilityImpl::WindowLifeCycleImpl::AfterBackground()
void AbilityImpl::WindowLifeCycleImpl::AfterFocused()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
auto owner = owner_.lock();
if (owner) {
owner->AfterFocused();
}
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::WindowLifeCycleImpl::AfterUnfocused()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
auto owner = owner_.lock();
if (owner) {
owner->AfterUnFocused();
}
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::WindowLifeCycleImpl::ForegroundFailed(int32_t type)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
PacMap restoreData;
switch (type) {
case static_cast<int32_t>(OHOS::Rosen::WMError::WM_ERROR_INVALID_OPERATION): {
HILOG_DEBUG("window was freezed.");
TAG_LOGD(AAFwkTag::ABILITY, "window was freezed.");
AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_,
AbilityLifeCycleState::ABILITY_STATE_WINDOW_FREEZED, restoreData);
break;
@@ -714,11 +719,11 @@ void AbilityImpl::WindowLifeCycleImpl::ForegroundFailed(int32_t type)
case static_cast<int32_t>(OHOS::Rosen::WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE): {
auto owner = owner_.lock();
if (owner == nullptr || !owner->IsStageBasedModel()) {
HILOG_ERROR("Not stage mode ability or abilityImpl is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "Not stage mode ability or abilityImpl is nullptr.");
return;
}
HILOG_DEBUG("The ability is stage mode, schedule foreground invalid mode.");
TAG_LOGD(AAFwkTag::ABILITY, "The ability is stage mode, schedule foreground invalid mode.");
AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_,
AbilityLifeCycleState::ABILITY_STATE_INVALID_WINDOW_MODE, restoreData);
break;
@@ -738,13 +743,13 @@ void AbilityImpl::WindowLifeCycleImpl::ForegroundFailed(int32_t type)
void AbilityImpl::Foreground(const Want &want)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Foreground ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Foreground ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
HILOG_DEBUG("AbilityImpl::Foreground");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::Foreground");
ability_->OnForeground(want);
if ((ability_->GetAbilityInfo()->type == AppExecFwk::AbilityType::PAGE) &&
(ability_->GetAbilityInfo()->isStageBasedModel)) {
@@ -756,12 +761,12 @@ void AbilityImpl::Foreground(const Want &want)
std::lock_guard<std::mutex> lock(notifyForegroundLock_);
notifyForegroundByAbility_ = true;
}
HILOG_INFO("%{public}s end.", __func__);
TAG_LOGI(AAFwkTag::ABILITY, "%{public}s end.", __func__);
}
void AbilityImpl::WindowLifeCycleImpl::BackgroundFailed(int32_t type)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (type == static_cast<int32_t>(OHOS::Rosen::WMError::WM_DO_NOTHING)) {
PacMap restoreData;
AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_,
@@ -771,9 +776,9 @@ void AbilityImpl::WindowLifeCycleImpl::BackgroundFailed(int32_t type)
void AbilityImpl::Background()
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (ability_ == nullptr || ability_->GetAbilityInfo() == nullptr || abilityLifecycleCallbacks_ == nullptr) {
HILOG_ERROR("AbilityImpl::Background ability_ or abilityLifecycleCallbacks_ is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImpl::Background ability_ or abilityLifecycleCallbacks_ is nullptr");
return;
}
ability_->OnLeaveForeground();
@@ -784,22 +789,22 @@ void AbilityImpl::Background()
} else {
lifecycleState_ = AAFwk::ABILITY_STATE_BACKGROUND;
}
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
}
void AbilityImpl::DoKeyDown(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
{
HILOG_DEBUG("AbilityImpl::DoKeyDown called");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DoKeyDown called");
}
void AbilityImpl::DoKeyUp(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
{
HILOG_DEBUG("AbilityImpl::DoKeyUp called");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DoKeyUp called");
}
void AbilityImpl::DoPointerEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent)
{
HILOG_DEBUG("AbilityImpl::DoPointerEvent called");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DoPointerEvent called");
}
void AbilityImpl::InputEventConsumerImpl::OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const
@@ -807,16 +812,16 @@ void AbilityImpl::InputEventConsumerImpl::OnInputEvent(std::shared_ptr<MMI::KeyE
int32_t code = keyEvent->GetKeyAction();
if (code == MMI::KeyEvent::KEY_ACTION_DOWN) {
abilityImpl_->DoKeyDown(keyEvent);
HILOG_DEBUG("AbilityImpl::OnKeyDown keyAction: %{public}d.", code);
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::OnKeyDown keyAction: %{public}d.", code);
} else if (code == MMI::KeyEvent::KEY_ACTION_UP) {
abilityImpl_->DoKeyUp(keyEvent);
HILOG_DEBUG("AbilityImpl::DoKeyUp keyAction: %{public}d.", code);
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DoKeyUp keyAction: %{public}d.", code);
}
}
void AbilityImpl::InputEventConsumerImpl::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
{
HILOG_DEBUG("AbilityImpl::DoPointerEvent called.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityImpl::DoPointerEvent called.");
abilityImpl_->DoPointerEvent(pointerEvent);
}
#endif
frameworks/native/ability/native/ability_impl_factory.cpp
+6 -4
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -15,6 +15,7 @@
#include "ability_impl_factory.h"
#include "data_ability_impl.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "new_ability_impl.h"
#ifdef SUPPORT_GRAPHICS
@@ -31,12 +32,13 @@ AbilityImplFactory::~AbilityImplFactory() {}
std::shared_ptr<AbilityImpl> AbilityImplFactory::MakeAbilityImplObject(const std::shared_ptr<AbilityInfo> &info)
{
if (info == nullptr) {
HILOG_ERROR("AbilityImplFactory::MakeAbilityImplObject is error nullptr == info ");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImplFactory::MakeAbilityImplObject is error nullptr == info ");
return nullptr;
}
std::shared_ptr<AbilityImpl> abilityImpl = nullptr;
HILOG_DEBUG("AbilityImplFactory::MakeAbilityImplObject type:%{public}d, isStageBasedModel:%{public}d", info->type,
TAG_LOGD(AAFwkTag::ABILITY,
"AbilityImplFactory::MakeAbilityImplObject type:%{public}d, isStageBasedModel:%{public}d", info->type,
info->isStageBasedModel);
switch (info->type) {
#ifdef SUPPORT_GRAPHICS
@@ -55,7 +57,7 @@ std::shared_ptr<AbilityImpl> AbilityImplFactory::MakeAbilityImplObject(const std
abilityImpl = std::make_shared<DataAbilityImpl>();
break;
default:
HILOG_ERROR("AbilityImplFactory::MakeAbilityImplObject is error");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityImplFactory::MakeAbilityImplObject is error");
break;
}
frameworks/native/ability/native/ability_lifecycle.cpp
+11 -10
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -14,22 +14,23 @@
*/
#include "ability_lifecycle_observer_interface.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
namespace OHOS {
namespace AppExecFwk {
LifeCycle::Event LifeCycle::GetLifecycleState()
{
HILOG_DEBUG("LifeCycle::GetLifecycleState: called");
TAG_LOGD(AAFwkTag::ABILITY, "LifeCycle::GetLifecycleState: called");
return state_;
}
void LifeCycle::AddObserver(const std::shared_ptr<ILifecycleObserver> &observer)
{
HILOG_DEBUG("LifeCycle::AddObserver: called");
TAG_LOGD(AAFwkTag::ABILITY, "LifeCycle::AddObserver: called");
if (observer == nullptr) {
HILOG_ERROR("LifeCycle::AddObserver: observer is null");
TAG_LOGE(AAFwkTag::ABILITY, "LifeCycle::AddObserver: observer is null");
return;
}
@@ -38,9 +39,9 @@ void LifeCycle::AddObserver(const std::shared_ptr<ILifecycleObserver> &observer)
void LifeCycle::DispatchLifecycle(const LifeCycle::Event &event, const Want &want)
{
HILOG_DEBUG("LifeCycle::DispatchLifecycle: event:%{public}d", event);
TAG_LOGD(AAFwkTag::ABILITY, "LifeCycle::DispatchLifecycle: event:%{public}d", event);
if ((event != LifeCycle::Event::ON_FOREGROUND) && (event != LifeCycle::Event::ON_START)) {
HILOG_ERROR("event value error: event is %{public}d", event);
TAG_LOGE(AAFwkTag::ABILITY, "event value error: event is %{public}d", event);
return;
}
@@ -74,10 +75,10 @@ void LifeCycle::DispatchLifecycle(const LifeCycle::Event &event, const Want &wan
void LifeCycle::DispatchLifecycle(const LifeCycle::Event &event)
{
HILOG_DEBUG("LifeCycle::DispatchLifecycle: event:%{public}d", event);
TAG_LOGD(AAFwkTag::ABILITY, "LifeCycle::DispatchLifecycle: event:%{public}d", event);
if ((event != LifeCycle::Event::ON_ACTIVE) && (event != LifeCycle::Event::ON_BACKGROUND) &&
(event != LifeCycle::Event::ON_INACTIVE) && (event != LifeCycle::Event::ON_STOP)) {
HILOG_ERROR("event value error: event is %{public}d", event);
TAG_LOGE(AAFwkTag::ABILITY, "event value error: event is %{public}d", event);
return;
}
@@ -123,10 +124,10 @@ void LifeCycle::DispatchLifecycle(const LifeCycle::Event &event)
void LifeCycle::RemoveObserver(const std::shared_ptr<ILifecycleObserver> &observer)
{
HILOG_DEBUG("LifeCycle::RemoveObserver: called");
TAG_LOGD(AAFwkTag::ABILITY, "LifeCycle::RemoveObserver: called");
if (observer == nullptr) {
HILOG_ERROR("LifeCycle::RemoveObserver: observer is null");
TAG_LOGE(AAFwkTag::ABILITY, "LifeCycle::RemoveObserver: observer is null");
return;
}
frameworks/native/ability/native/ability_loader.cpp
+10 -9
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -14,6 +14,7 @@
*/
#include "ability_loader.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
namespace OHOS {
@@ -27,18 +28,18 @@ AbilityLoader &AbilityLoader::GetInstance()
void AbilityLoader::RegisterAbility(const std::string &abilityName, const CreateAblity &createFunc)
{
abilities_.insert_or_assign(abilityName, createFunc);
HILOG_DEBUG("AbilityLoader::RegisterAbility:%{public}s", abilityName.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "AbilityLoader::RegisterAbility:%{public}s", abilityName.c_str());
}
void AbilityLoader::RegisterExtension(const std::string &abilityName, const CreateExtension &createFunc)
{
extensions_.emplace(abilityName, createFunc);
HILOG_DEBUG("AbilityLoader::RegisterExtension:%{public}s", abilityName.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "AbilityLoader::RegisterExtension:%{public}s", abilityName.c_str());
}
void AbilityLoader::RegisterUIAbility(const std::string &abilityName, const CreateUIAbility &createFunc)
{
HILOG_DEBUG("RegisterUIAbility: %{public}s", abilityName.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "RegisterUIAbility: %{public}s", abilityName.c_str());
uiAbilities_.emplace(abilityName, createFunc);
}
@@ -48,7 +49,7 @@ Ability *AbilityLoader::GetAbilityByName(const std::string &abilityName)
if (it != abilities_.end()) {
return it->second();
}
HILOG_ERROR("AbilityLoader::GetAbilityByName failed:%{public}s", abilityName.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "AbilityLoader::GetAbilityByName failed:%{public}s", abilityName.c_str());
return nullptr;
}
@@ -58,7 +59,7 @@ AbilityRuntime::Extension *AbilityLoader::GetExtensionByName(const std::string &
if (it != extensions_.end()) {
return it->second();
}
HILOG_ERROR("AbilityLoader::GetExtensionByName failed:%{public}s", abilityName.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "AbilityLoader::GetExtensionByName failed:%{public}s", abilityName.c_str());
return nullptr;
}
@@ -68,7 +69,7 @@ AbilityRuntime::UIAbility *AbilityLoader::GetUIAbilityByName(const std::string &
if (it != uiAbilities_.end()) {
return it->second();
}
HILOG_ERROR("GetAbilityByName failed: %{public}s", abilityName.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "GetAbilityByName failed: %{public}s", abilityName.c_str());
return nullptr;
}
@@ -76,7 +77,7 @@ AbilityRuntime::UIAbility *AbilityLoader::GetUIAbilityByName(const std::string &
void AbilityLoader::RegisterAbilitySlice(const std::string &sliceName, const CreateSlice &createFunc)
{
slices_.emplace(sliceName, createFunc);
HILOG_DEBUG(HILOG_MODULE_APP, "RegisterAbilitySlice %s", sliceName.c_str());
TAG_LOGD(AAFwkTag::ABILITY, HILOG_MODULE_APP, "RegisterAbilitySlice %s", sliceName.c_str());
}
AbilitySlice *AbilityLoader::GetAbilitySliceByName(const std::string &sliceName)
@@ -85,7 +86,7 @@ AbilitySlice *AbilityLoader::GetAbilitySliceByName(const std::string &sliceName)
if (it != slices_.end()) {
return it->second();
}
HILOG_ERROR(HILOG_MODULE_APP, "GetAbilitySliceByName failed: %s", sliceName.c_str());
TAG_LOGE(AAFwkTag::ABILITY, HILOG_MODULE_APP, "GetAbilitySliceByName failed: %s", sliceName.c_str());
return nullptr;
}
#endif
frameworks/native/ability/native/ability_post_event_timeout.cpp
+11 -8
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -16,6 +16,7 @@
#include "ability_post_event_timeout.h"
#include "ability_handler.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
namespace OHOS {
@@ -39,9 +40,10 @@ AbilityPostEventTimeout::~AbilityPostEventTimeout()
void AbilityPostEventTimeout::TimingBegin(int64_t delaytime)
{
HILOG_INFO("AbilityPostEventTimeout::TimingBegin() call %{public}s", task_.c_str());
TAG_LOGI(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimingBegin() call %{public}s", task_.c_str());
if (handler_ == nullptr) {
HILOG_ERROR("AbilityPostEventTimeout::TimingBegin %{public}s handler_ is nullptr", task_.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimingBegin %{public}s handler_ is nullptr",
task_.c_str());
return;
}
@@ -51,7 +53,7 @@ void AbilityPostEventTimeout::TimingBegin(int64_t delaytime)
void AbilityPostEventTimeout::TimeEnd()
{
if (handler_ == nullptr) {
HILOG_ERROR("AbilityPostEventTimeout::TimeEnd %{public}s handler_ is nullptr", task_.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimeEnd %{public}s handler_ is nullptr", task_.c_str());
return;
}
@@ -64,19 +66,20 @@ void AbilityPostEventTimeout::TimeEnd()
void AbilityPostEventTimeout::TimeOutProc()
{
HILOG_INFO("AbilityPostEventTimeout::TimeOutProc() call %{public}s", task_.c_str());
TAG_LOGI(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimeOutProc() call %{public}s", task_.c_str());
if (handler_ == nullptr) {
HILOG_ERROR("AbilityPostEventTimeout::TimeEnd %{public}s handler_ is nullptr", task_.c_str());
TAG_LOGE(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimeEnd %{public}s handler_ is nullptr", task_.c_str());
return;
}
std::lock_guard<std::mutex> lck(mtx_);
if (!taskExec_) {
taskExec_ = true;
HILOG_WARN("TimeOutProc %{public}s Event TimeOut", task_.c_str());
TAG_LOGW(AAFwkTag::ABILITY, "TimeOutProc %{public}s Event TimeOut", task_.c_str());
handler_->RemoveTask(task_);
} else {
HILOG_WARN("AbilityPostEventTimeout::TimeOutProc Exec Failed, The Event is %{public}s", task_.c_str());
TAG_LOGW(AAFwkTag::ABILITY, "AbilityPostEventTimeout::TimeOutProc Exec Failed, The Event is %{public}s",
task_.c_str());
}
}
} // namespace AppExecFwk
frameworks/native/ability/native/ability_process.cpp
+32 -31
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -18,6 +18,7 @@
#include <dlfcn.h>
#include "accesstoken_kit.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "permission_list_state.h"
@@ -65,9 +66,9 @@ AbilityProcess::~AbilityProcess()
ErrCode AbilityProcess::StartAbility(Ability *ability, CallAbilityParam param, CallbackInfo callback)
{
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
if (ability == nullptr) {
HILOG_ERROR("ability is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "ability is nullptr");
return ERR_NULL_OBJECT;
}
#ifdef SUPPORT_GRAPHICS
@@ -77,16 +78,16 @@ ErrCode AbilityProcess::StartAbility(Ability *ability, CallAbilityParam param, C
windowMode == AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY) {
param.want.SetParam(Want::PARAM_RESV_WINDOW_MODE, windowMode);
}
HILOG_INFO("window mode is %{public}d", windowMode);
TAG_LOGI(AAFwkTag::ABILITY, "window mode is %{public}d", windowMode);
#endif
ErrCode err = ERR_OK;
if (param.forResultOption == true) {
if (param.setting == nullptr) {
HILOG_INFO("param.setting == nullptr call StartAbilityForResult.");
TAG_LOGI(AAFwkTag::ABILITY, "param.setting == nullptr call StartAbilityForResult.");
param.want.SetParam(Want::PARAM_RESV_FOR_RESULT, true);
err = ability->StartAbilityForResult(param.want, param.requestCode);
} else {
HILOG_INFO("param.setting != nullptr call StartAbilityForResult.");
TAG_LOGI(AAFwkTag::ABILITY, "param.setting != nullptr call StartAbilityForResult.");
err = ability->StartAbilityForResult(param.want, param.requestCode, *(param.setting));
}
@@ -95,9 +96,9 @@ ErrCode AbilityProcess::StartAbility(Ability *ability, CallAbilityParam param, C
std::map<int, CallbackInfo> map;
auto it = abilityResultMap_.find(ability);
if (it == abilityResultMap_.end()) {
HILOG_INFO("ability is not in the abilityResultMap_");
TAG_LOGI(AAFwkTag::ABILITY, "ability is not in the abilityResultMap_");
} else {
HILOG_INFO("ability is in the abilityResultMap_");
TAG_LOGI(AAFwkTag::ABILITY, "ability is in the abilityResultMap_");
map = it->second;
}
callback.errCode = err;
@@ -105,14 +106,14 @@ ErrCode AbilityProcess::StartAbility(Ability *ability, CallAbilityParam param, C
abilityResultMap_[ability] = map;
} else {
if (param.setting == nullptr) {
HILOG_INFO("param.setting == nullptr call StartAbility.");
TAG_LOGI(AAFwkTag::ABILITY, "param.setting == nullptr call StartAbility.");
err = ability->StartAbility(param.want);
} else {
HILOG_INFO("param.setting != nullptr call StartAbility.");
TAG_LOGI(AAFwkTag::ABILITY, "param.setting != nullptr call StartAbility.");
err = ability->StartAbility(param.want, *(param.setting));
}
}
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
return err;
}
@@ -124,9 +125,9 @@ void AbilityProcess::AddAbilityResultCallback(Ability *ability, CallAbilityParam
std::map<int, CallbackInfo> map;
auto it = abilityResultMap_.find(ability);
if (it == abilityResultMap_.end()) {
HILOG_INFO("ability is not in the abilityResultMap_");
TAG_LOGI(AAFwkTag::ABILITY, "ability is not in the abilityResultMap_");
} else {
HILOG_INFO("ability is in the abilityResultMap_");
TAG_LOGI(AAFwkTag::ABILITY, "ability is in the abilityResultMap_");
map = it->second;
}
callback.errCode = errCode;
@@ -136,20 +137,20 @@ void AbilityProcess::AddAbilityResultCallback(Ability *ability, CallAbilityParam
void AbilityProcess::OnAbilityResult(Ability *ability, int requestCode, int resultCode, const Want &resultData)
{
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
std::lock_guard<std::mutex> lock_l(mutex_);
auto it = abilityResultMap_.find(ability);
if (it == abilityResultMap_.end()) {
HILOG_ERROR("ability is not in the abilityResultMap");
TAG_LOGE(AAFwkTag::ABILITY, "ability is not in the abilityResultMap");
return;
}
std::map<int, CallbackInfo> map = it->second;
auto callback = map.find(requestCode);
if (callback == map.end()) {
HILOG_ERROR("requestCode: %{public}d is not in the map", requestCode);
TAG_LOGE(AAFwkTag::ABILITY, "requestCode: %{public}d is not in the map", requestCode);
return;
}
CallbackInfo callbackInfo = callback->second;
@@ -158,7 +159,7 @@ void AbilityProcess::OnAbilityResult(Ability *ability, int requestCode, int resu
if (g_handle == nullptr) {
g_handle = dlopen(SHARED_LIBRARY_FEATURE_ABILITY, RTLD_LAZY);
if (g_handle == nullptr) {
HILOG_ERROR("dlopen failed %{public}s. %{public}s",
TAG_LOGE(AAFwkTag::ABILITY, "dlopen failed %{public}s. %{public}s",
SHARED_LIBRARY_FEATURE_ABILITY,
dlerror());
return;
@@ -168,7 +169,7 @@ void AbilityProcess::OnAbilityResult(Ability *ability, int requestCode, int resu
// get function
auto func = reinterpret_cast<NAPICallOnAbilityResult>(dlsym(g_handle, FUNC_CALL_ON_ABILITY_RESULT));
if (func == nullptr) {
HILOG_ERROR("dlsym failed %{public}s. %{public}s", FUNC_CALL_ON_ABILITY_RESULT, dlerror());
TAG_LOGE(AAFwkTag::ABILITY, "dlsym failed %{public}s. %{public}s", FUNC_CALL_ON_ABILITY_RESULT, dlerror());
dlclose(g_handle);
g_handle = nullptr;
return;
@@ -178,48 +179,48 @@ void AbilityProcess::OnAbilityResult(Ability *ability, int requestCode, int resu
map.erase(requestCode);
abilityResultMap_[ability] = map;
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
}
void AbilityProcess::RequestPermissionsFromUser(
Ability *ability, CallAbilityPermissionParam &param, CallbackInfo callbackInfo)
{
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
if (ability == nullptr) {
HILOG_ERROR("ability is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "ability is nullptr");
return;
}
std::vector<PermissionListState> permList;
for (auto permission : param.permission_list) {
HILOG_DEBUG("permission: %{public}s.", permission.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "permission: %{public}s.", permission.c_str());
PermissionListState permState;
permState.permissionName = permission;
permState.state = Security::AccessToken::SETTING_OPER;
permList.emplace_back(permState);
}
HILOG_DEBUG("permList size: %{public}zu, permissions size: %{public}zu.",
TAG_LOGD(AAFwkTag::ABILITY, "permList size: %{public}zu, permissions size: %{public}zu.",
permList.size(), param.permission_list.size());
Security::AccessToken::PermissionGrantInfo grantInfo;
auto ret = AccessTokenKit::GetSelfPermissionsState(permList, grantInfo);
if (permList.size() != param.permission_list.size()) {
HILOG_ERROR("Returned permList size: %{public}zu.", permList.size());
TAG_LOGE(AAFwkTag::ABILITY, "Returned permList size: %{public}zu.", permList.size());
return;
}
std::vector<int> permissionsState;
for (auto permState : permList) {
HILOG_DEBUG("permissions: %{public}s. permissionsState: %{public}u",
TAG_LOGD(AAFwkTag::ABILITY, "permissions: %{public}s. permissionsState: %{public}u",
permState.permissionName.c_str(), permState.state);
permissionsState.emplace_back(permState.state);
}
HILOG_DEBUG("permissions size: %{public}zu. permissionsState size: %{public}zu",
TAG_LOGD(AAFwkTag::ABILITY, "permissions size: %{public}zu. permissionsState size: %{public}zu",
param.permission_list.size(), permissionsState.size());
auto requestCode = param.requestCode;
if (ret != TypePermissionOper::DYNAMIC_OPER) {
HILOG_DEBUG("No dynamic popup required.");
TAG_LOGD(AAFwkTag::ABILITY, "No dynamic popup required.");
(void)CaullFunc(requestCode, param.permission_list, permissionsState, callbackInfo);
return;
}
@@ -227,11 +228,11 @@ void AbilityProcess::RequestPermissionsFromUser(
auto task = [self = GetInstance(), requestCode, callbackInfo]
(const std::vector<std::string> &permissions, const std::vector<int> &grantResults) mutable {
if (!self) {
HILOG_ERROR("self is nullptr.");
TAG_LOGE(AAFwkTag::ABILITY, "self is nullptr.");
return;
}
if (!self->CaullFunc(requestCode, permissions, grantResults, callbackInfo)) {
HILOG_ERROR("call function failed.");
TAG_LOGE(AAFwkTag::ABILITY, "call function failed.");
return;
}
};
@@ -247,7 +248,7 @@ bool AbilityProcess::CaullFunc(int requestCode, const std::vector<std::string> &
if (g_handle == nullptr) {
g_handle = dlopen(SHARED_LIBRARY_FEATURE_ABILITY, RTLD_LAZY);
if (g_handle == nullptr) {
HILOG_ERROR("dlopen failed %{public}s. %{public}s",
TAG_LOGE(AAFwkTag::ABILITY, "dlopen failed %{public}s. %{public}s",
SHARED_LIBRARY_FEATURE_ABILITY, dlerror());
return false;
}
@@ -257,7 +258,7 @@ bool AbilityProcess::CaullFunc(int requestCode, const std::vector<std::string> &
auto func = reinterpret_cast<NAPICallOnRequestPermissionsFromUserResult>(
dlsym(g_handle, FUNC_CALL_ON_REQUEST_PERMISSIONS_FROM_USERRESULT));
if (func == nullptr) {
HILOG_ERROR("dlsym failed %{public}s. %{public}s",
TAG_LOGE(AAFwkTag::ABILITY, "dlsym failed %{public}s. %{public}s",
FUNC_CALL_ON_REQUEST_PERMISSIONS_FROM_USERRESULT, dlerror());
dlclose(g_handle);
g_handle = nullptr;
frameworks/native/ability/native/ability_thread.cpp
+48 -47
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -18,6 +18,7 @@
#include "extension_ability_thread.h"
#include "fa_ability_thread.h"
#include "ui_ability_thread.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "hitrace_meter.h"
@@ -31,14 +32,14 @@ void AbilityThread::AbilityThreadMain(const std::shared_ptr<OHOSApplication> &ap
const std::shared_ptr<AbilityRuntime::Context> &stageContext)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
if (abilityRecord == nullptr) {
HILOG_ERROR("abilityRecord is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "abilityRecord is nullptr");
return;
}
std::shared_ptr<AbilityInfo> abilityInfo = abilityRecord->GetAbilityInfo();
if (abilityInfo == nullptr) {
HILOG_ERROR("abilityInfo is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "abilityInfo is nullptr");
return;
}
@@ -51,11 +52,11 @@ void AbilityThread::AbilityThreadMain(const std::shared_ptr<OHOSApplication> &ap
thread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
}
if (thread == nullptr) {
HILOG_ERROR("thread is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "thread is nullptr");
return;
}
thread->Attach(application, abilityRecord, mainRunner, stageContext);
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
}
void AbilityThread::AbilityThreadMain(const std::shared_ptr<OHOSApplication> &application,
@@ -63,15 +64,15 @@ void AbilityThread::AbilityThreadMain(const std::shared_ptr<OHOSApplication> &ap
const std::shared_ptr<AbilityRuntime::Context> &stageContext)
{
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
if (abilityRecord == nullptr) {
HILOG_ERROR("abilityRecord is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "abilityRecord is nullptr");
return;
}
std::shared_ptr<AbilityInfo> abilityInfo = abilityRecord->GetAbilityInfo();
if (abilityInfo == nullptr) {
HILOG_ERROR("abilityInfo is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "abilityInfo is nullptr");
return;
}
@@ -84,214 +85,214 @@ void AbilityThread::AbilityThreadMain(const std::shared_ptr<OHOSApplication> &ap
thread = new (std::nothrow) AbilityRuntime::FAAbilityThread();
}
if (thread == nullptr) {
HILOG_ERROR("thread is nullptr");
TAG_LOGE(AAFwkTag::ABILITY, "thread is nullptr");
return;
}
thread->Attach(application, abilityRecord, stageContext);
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
}
void AbilityThread::ScheduleAbilityTransaction(
const Want &want, const LifeCycleStateInfo &targetState, sptr<SessionInfo> sessionInfo)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleShareData(const int32_t &requestCode)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleConnectAbility(const Want &want)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleDisconnectAbility(const Want &want)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleCommandAbility(const Want &want, bool restart, int startId)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleCommandAbilityWindow(
const Want &want, const sptr<AAFwk::SessionInfo> &sessionInfo, AAFwk::WindowCommand winCmd)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
bool AbilityThread::SchedulePrepareTerminateAbility()
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return false;
}
void AbilityThread::ScheduleSaveAbilityState()
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::ScheduleRestoreAbilityState(const PacMap &state)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::SendResult(int requestCode, int resultCode, const Want &resultData)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
std::vector<std::string> AbilityThread::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
std::vector<std::string> types;
return types;
}
int AbilityThread::OpenFile(const Uri &uri, const std::string &mode)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
int AbilityThread::OpenRawFile(const Uri &uri, const std::string &mode)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
int AbilityThread::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
std::shared_ptr<AppExecFwk::PacMap> AbilityThread::Call(
const Uri &uri, const std::string &method, const std::string &arg, const AppExecFwk::PacMap &pacMap)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return nullptr;
}
int AbilityThread::Update(
const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
int AbilityThread::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
std::shared_ptr<NativeRdb::AbsSharedResultSet> AbilityThread::Query(
const Uri &uri, std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return nullptr;
}
std::string AbilityThread::GetType(const Uri &uri)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return "";
}
bool AbilityThread::Reload(const Uri &uri, const PacMap &extras)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return false;
}
int AbilityThread::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
void AbilityThread::ContinueAbility(const std::string &deviceId, uint32_t versionCode)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::NotifyContinuationResult(int32_t result)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
Uri AbilityThread::NormalizeUri(const Uri &uri)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return uri;
}
Uri AbilityThread::DenormalizeUri(const Uri &uri)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return uri;
}
bool AbilityThread::ScheduleRegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return false;
}
bool AbilityThread::ScheduleUnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return false;
}
bool AbilityThread::ScheduleNotifyChange(const Uri &uri)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return false;
}
void AbilityThread::DumpAbilityInfo(const std::vector<std::string> &params, std::vector<std::string> &info)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::CallRequest()
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
void AbilityThread::OnExecuteIntent(const Want &want)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
std::vector<std::shared_ptr<AppExecFwk::DataAbilityResult>> AbilityThread::ExecuteBatch(
const std::vector<std::shared_ptr<AppExecFwk::DataAbilityOperation>> &operations)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
std::vector<std::shared_ptr<DataAbilityResult>> results;
return results;
}
int AbilityThread::CreateModalUIExtension(const Want &want)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
return ERR_INVALID_VALUE;
}
void AbilityThread::UpdateSessionToken(sptr<IRemoteObject> sessionToken)
{
HILOG_DEBUG("called");
TAG_LOGD(AAFwkTag::ABILITY, "called");
}
#ifdef ABILITY_COMMAND_FOR_TEST
int AbilityThread::BlockAbility()
{
HILOG_DEBUG("begin");
TAG_LOGD(AAFwkTag::ABILITY, "begin");
if (abilityHandler_) {
auto task = []() {
while (1) {
@@ -299,7 +300,7 @@ int AbilityThread::BlockAbility()
}
};
abilityHandler_->PostTask(task, "AbilityThread:BlockAbility");
HILOG_DEBUG("end");
TAG_LOGD(AAFwkTag::ABILITY, "end");
return ERR_OK;
}
return ERR_NO_INIT;
frameworks/native/ability/native/ability_window.cpp
+29 -26
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -16,6 +16,7 @@
#include "ability_window.h"
#include "ability.h"
#include "ability_handler.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "scene_board_judgement.h"
@@ -34,7 +35,7 @@ AbilityWindow::~AbilityWindow()
*/
void AbilityWindow::Init(std::shared_ptr<AbilityHandler>& handler, std::shared_ptr<Ability> ability)
{
HILOG_DEBUG("%{public}s come.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s come.", __func__);
handler_ = handler;
ability_ = std::weak_ptr<IAbilityEvent>(ability);
windowScene_ = std::make_shared<Rosen::WindowScene>();
@@ -43,7 +44,7 @@ void AbilityWindow::Init(std::shared_ptr<AbilityHandler>& handler, std::shared_p
bool AbilityWindow::InitWindow(std::shared_ptr<AbilityRuntime::AbilityContext> &abilityContext,
sptr<Rosen::IWindowLifeCycle> &listener, int32_t displayId, sptr<Rosen::WindowOption> option, bool isPrivacy)
{
HILOG_DEBUG("%{public}s begin.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin.", __func__);
if (windowScene_ == nullptr) {
windowScene_ = std::make_shared<Rosen::WindowScene>();
}
@@ -55,13 +56,13 @@ bool AbilityWindow::InitWindow(std::shared_ptr<AbilityRuntime::AbilityContext> &
ret = windowScene_->Init(displayId, abilityContext, listener, option);
}
if (ret != OHOS::Rosen::WMError::WM_OK) {
HILOG_ERROR("%{public}s error. failed to init window scene!", __func__);
TAG_LOGE(AAFwkTag::ABILITY, "%{public}s error. failed to init window scene!", __func__);
return false;
}
auto window = windowScene_->GetMainWindow();
if (!window) {
HILOG_ERROR("%{public}s window is nullptr.", __func__);
TAG_LOGE(AAFwkTag::ABILITY, "%{public}s window is nullptr.", __func__);
return false;
}
@@ -70,7 +71,7 @@ bool AbilityWindow::InitWindow(std::shared_ptr<AbilityRuntime::AbilityContext> &
}
isWindowAttached = true;
HILOG_DEBUG("%{public}s end.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end.", __func__);
return true;
}
@@ -80,19 +81,20 @@ bool AbilityWindow::InitWindow(std::shared_ptr<AbilityRuntime::AbilityContext> &
*/
void AbilityWindow::OnPostAbilityBackground(uint32_t sceneFlag)
{
HILOG_DEBUG("AbilityWindow::OnPostAbilityBackground called.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityBackground called.");
if (!isWindowAttached) {
HILOG_ERROR("AbilityWindow::OnPostAbilityBackground window not attached.");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityBackground window not attached.");
return;
}
if (windowScene_) {
HILOG_DEBUG("%{public}s begin windowScene_->GoBackground, sceneFlag:%{public}d.", __func__, sceneFlag);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin windowScene_->GoBackground, sceneFlag:%{public}d.",
__func__, sceneFlag);
windowScene_->GoBackground(sceneFlag);
HILOG_DEBUG("%{public}s end windowScene_->GoBackground.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end windowScene_->GoBackground.", __func__);
}
HILOG_DEBUG("AbilityWindow::OnPostAbilityBackground end.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityBackground end.");
}
/**
@@ -101,19 +103,20 @@ void AbilityWindow::OnPostAbilityBackground(uint32_t sceneFlag)
*/
void AbilityWindow::OnPostAbilityForeground(uint32_t sceneFlag)
{
HILOG_DEBUG("AbilityWindow::OnPostAbilityForeground called.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityForeground called.");
if (!isWindowAttached) {
HILOG_ERROR("AbilityWindow::OnPostAbilityForeground window not attached.");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityForeground window not attached.");
return;
}
if (windowScene_) {
HILOG_DEBUG("%{public}s begin windowScene_->GoForeground, sceneFlag:%{public}d.", __func__, sceneFlag);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s begin windowScene_->GoForeground, sceneFlag:%{public}d.",
__func__, sceneFlag);
windowScene_->GoForeground(sceneFlag);
HILOG_DEBUG("%{public}s end windowScene_->GoForeground.", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s end windowScene_->GoForeground.", __func__);
}
HILOG_DEBUG("AbilityWindow::OnPostAbilityForeground end.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityForeground end.");
}
/**
@@ -122,9 +125,9 @@ void AbilityWindow::OnPostAbilityForeground(uint32_t sceneFlag)
*/
void AbilityWindow::OnPostAbilityStop()
{
HILOG_DEBUG("AbilityWindow::OnPostAbilityStop called.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityStop called.");
if (!isWindowAttached) {
HILOG_ERROR("AbilityWindow::OnPostAbilityStop window not attached.");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityStop window not attached.");
return;
}
@@ -132,7 +135,7 @@ void AbilityWindow::OnPostAbilityStop()
windowScene_->GoDestroy();
}
isWindowAttached = false;
HILOG_DEBUG("AbilityWindow::OnPostAbilityStop end.");
TAG_LOGD(AAFwkTag::ABILITY, "AbilityWindow::OnPostAbilityStop end.");
}
/**
@@ -143,7 +146,7 @@ void AbilityWindow::OnPostAbilityStop()
const sptr<Rosen::Window> AbilityWindow::GetWindow()
{
if (!isWindowAttached) {
HILOG_ERROR("AbilityWindow::GetWindow window not attached.");
TAG_LOGE(AAFwkTag::ABILITY, "AbilityWindow::GetWindow window not attached.");
return nullptr;
}
return windowScene_ ? windowScene_->GetMainWindow() : nullptr;
@@ -152,16 +155,16 @@ const sptr<Rosen::Window> AbilityWindow::GetWindow()
#ifdef SUPPORT_GRAPHICS
ErrCode AbilityWindow::SetMissionLabel(const std::string &label)
{
HILOG_DEBUG("%{public}s start", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s start", __func__);
auto window = GetWindow();
if (!window) {
HILOG_ERROR("get window failed.");
TAG_LOGE(AAFwkTag::ABILITY, "get window failed.");
return -1;
}
auto ret = window->SetAPPWindowLabel(label);
if (ret != OHOS::Rosen::WMError::WM_OK) {
HILOG_ERROR("SetAPPWindowLabel failed, errCode:%{public}d.", ret);
TAG_LOGE(AAFwkTag::ABILITY, "SetAPPWindowLabel failed, errCode:%{public}d.", ret);
return -1;
}
@@ -170,16 +173,16 @@ ErrCode AbilityWindow::SetMissionLabel(const std::string &label)
ErrCode AbilityWindow::SetMissionIcon(const std::shared_ptr<OHOS::Media::PixelMap> &icon)
{
HILOG_DEBUG("%{public}s start", __func__);
TAG_LOGD(AAFwkTag::ABILITY, "%{public}s start", __func__);
auto window = GetWindow();
if (!window) {
HILOG_ERROR("get window failed, will not set mission icon.");
TAG_LOGE(AAFwkTag::ABILITY, "get window failed, will not set mission icon.");
return -1;
}
auto ret = window->SetAPPWindowIcon(icon);
if (ret != OHOS::Rosen::WMError::WM_OK) {
HILOG_ERROR("SetAPPWindowIcon failed, errCode:%{public}d.", ret);
TAG_LOGE(AAFwkTag::ABILITY, "SetAPPWindowIcon failed, errCode:%{public}d.", ret);
return -1;
}
frameworks/native/ability/native/app_module_checker.cpp
+3 -2
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -15,6 +15,7 @@
#include "app_module_checker.h"
#include "hilog_tag_wrapper.h"
#include "module_checker_delegate.h"
#include "utils/log.h"
@@ -22,7 +23,7 @@ bool AppModuleChecker::CheckModuleLoadable(const char *moduleName,
std::unique_ptr<ApiAllowListChecker> &apiAllowListChecker)
{
apiAllowListChecker = nullptr;
HILOG_DEBUG("check blocklist, moduleName = %{public}s, processExtensionType_ = %{public}d",
TAG_LOGD(AAFwkTag::ABILITY, "check blocklist, moduleName = %{public}s, processExtensionType_ = %{public}d",
moduleName, static_cast<int32_t>(processExtensionType_));
const auto& blockListIter = moduleBlocklist_.find(processExtensionType_);
if (blockListIter == moduleBlocklist_.end()) {
frameworks/native/ability/native/auto_startup_callback_proxy.cpp
+9 -8
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -16,6 +16,7 @@
#include "auto_startup_callback_proxy.h"
#include "ability_manager_errors.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "ipc_types.h"
#include "message_parcel.h"
@@ -29,18 +30,18 @@ void AutoStartupCallBackProxy::OnAutoStartupOn(const AutoStartupInfo &info)
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(AutoStartupCallBackProxy::GetDescriptor())) {
HILOG_ERROR("Write interface token failed.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Write interface token failed.");
return;
}
if (!data.WriteParcelable(&info)) {
HILOG_ERROR("Write AutoStartupInfo failed.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Write AutoStartupInfo failed.");
return;
}
auto ret = SendRequest(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_ON, data, reply, option);
if (ret != NO_ERROR) {
HILOG_ERROR("Send request error: %{public}d.", ret);
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Send request error: %{public}d.", ret);
}
}
@@ -50,18 +51,18 @@ void AutoStartupCallBackProxy::OnAutoStartupOff(const AutoStartupInfo &info)
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(AutoStartupCallBackProxy::GetDescriptor())) {
HILOG_ERROR("Write interface token failed.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Write interface token failed.");
return;
}
if (!data.WriteParcelable(&info)) {
HILOG_ERROR("Write AutoStartupInfo failed.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Write AutoStartupInfo failed.");
return;
}
auto ret = SendRequest(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_OFF, data, reply, option);
if (ret != NO_ERROR) {
HILOG_ERROR("Send request error: %{public}d.", ret);
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Send request error: %{public}d.", ret);
}
}
@@ -70,7 +71,7 @@ ErrCode AutoStartupCallBackProxy::SendRequest(
{
sptr<IRemoteObject> remote = Remote();
if (remote == nullptr) {
HILOG_ERROR("Remote is nullptr.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Remote is nullptr.");
return INNER_ERR;
}
frameworks/native/ability/native/auto_startup_callback_stub.cpp
+8 -7
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -18,6 +18,7 @@
#include "ability_manager_ipc_interface_code.h"
#include "auto_startup_info.h"
#include "event_handler.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "ipc_types.h"
#include "message_parcel.h"
@@ -49,7 +50,7 @@ int AutoStartupCallBackStub::OnRemoteRequest(
std::u16string autoStartUpCallBackDescriptor = AutoStartupCallBackStub::GetDescriptor();
std::u16string remoteDescriptor = data.ReadInterfaceToken();
if (autoStartUpCallBackDescriptor != remoteDescriptor) {
HILOG_ERROR("Local descriptor is not equal to remote.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Local descriptor is not equal to remote.");
return ERR_INVALID_STATE;
}
@@ -60,7 +61,7 @@ int AutoStartupCallBackStub::OnRemoteRequest(
return (this->*requestFunc)(data, reply);
}
}
HILOG_WARN("Default case, need check.");
TAG_LOGW(AAFwkTag::AUTO_STARTUP, "Default case, need check.");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
@@ -68,7 +69,7 @@ int32_t AutoStartupCallBackStub::OnAutoStartupOnInner(MessageParcel &data, Messa
{
sptr<AutoStartupInfo> info = data.ReadParcelable<AutoStartupInfo>();
if (info == nullptr) {
HILOG_ERROR("Failed to read parcelable.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Failed to read parcelable.");
return ERR_INVALID_VALUE;
}
@@ -78,7 +79,7 @@ int32_t AutoStartupCallBackStub::OnAutoStartupOnInner(MessageParcel &data, Messa
handler->PostSyncTask([weak, info]() {
auto autoStartUpCallBackStub = weak.promote();
if (autoStartUpCallBackStub == nullptr) {
HILOG_ERROR("autoStartUpCallBackStub is nullptr.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "autoStartUpCallBackStub is nullptr.");
return;
}
autoStartUpCallBackStub->OnAutoStartupOn(*info);
@@ -91,7 +92,7 @@ int32_t AutoStartupCallBackStub::OnAutoStartupOffInner(MessageParcel &data, Mess
{
sptr<AutoStartupInfo> info = data.ReadParcelable<AutoStartupInfo>();
if (info == nullptr) {
HILOG_ERROR("Failed to read parcelable.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "Failed to read parcelable.");
return ERR_INVALID_VALUE;
}
@@ -101,7 +102,7 @@ int32_t AutoStartupCallBackStub::OnAutoStartupOffInner(MessageParcel &data, Mess
handler->PostSyncTask([weak, info]() {
auto autoStartUpCallBackStub = weak.promote();
if (autoStartUpCallBackStub == nullptr) {
HILOG_ERROR("autoStartUpCallBackStub is nullptr.");
TAG_LOGE(AAFwkTag::AUTO_STARTUP, "autoStartUpCallBackStub is nullptr.");
return;
}
autoStartUpCallBackStub->OnAutoStartupOff(*info);
frameworks/native/ability/native/configuration_utils.cpp
+27 -24
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -16,6 +16,7 @@
#include "configuration_utils.h"
#include "configuration_convertor.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#ifdef SUPPORT_GRAPHICS
#include "window.h"
@@ -28,9 +29,9 @@ using namespace AppExecFwk;
void ConfigurationUtils::UpdateGlobalConfig(const Configuration &configuration,
std::shared_ptr<ResourceManager> resourceManager)
{
HILOG_DEBUG("Enter");
TAG_LOGD(AAFwkTag::ABILITY, "Enter");
if (resourceManager == nullptr) {
HILOG_ERROR("Resource manager is invalid.");
TAG_LOGE(AAFwkTag::ABILITY, "Resource manager is invalid.");
return;
}
@@ -40,7 +41,7 @@ void ConfigurationUtils::UpdateGlobalConfig(const Configuration &configuration,
GetGlobalConfig(configuration, language, colormode, hasPointerDevice);
std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
if (resConfig == nullptr) {
HILOG_ERROR("Create resource config failed.");
TAG_LOGE(AAFwkTag::ABILITY, "Create resource config failed.");
return;
}
resourceManager->GetResConfig(*resConfig);
@@ -49,14 +50,14 @@ void ConfigurationUtils::UpdateGlobalConfig(const Configuration &configuration,
if (!language.empty()) {
UErrorCode status = U_ZERO_ERROR;
icu::Locale locale = icu::Locale::forLanguageTag(language, status);
HILOG_DEBUG("get Locale::forLanguageTag return[%{public}d].", static_cast<int>(status));
TAG_LOGD(AAFwkTag::ABILITY, "get Locale::forLanguageTag return[%{public}d].", static_cast<int>(status));
if (status == U_ZERO_ERROR) {
resConfig->SetLocaleInfo(locale);
}
const icu::Locale *localeInfo = resConfig->GetLocaleInfo();
if (localeInfo != nullptr) {
HILOG_DEBUG("Update config, language: %{public}s, script: %{public}s, region: %{public}s",
TAG_LOGD(AAFwkTag::ABILITY, "Update config, language: %{public}s, script: %{public}s, region: %{public}s",
localeInfo->getLanguage(), localeInfo->getScript(), localeInfo->getCountry());
}
}
@@ -64,21 +65,21 @@ void ConfigurationUtils::UpdateGlobalConfig(const Configuration &configuration,
if (!colormode.empty()) {
resConfig->SetColorMode(AppExecFwk::ConvertColorMode(colormode));
HILOG_DEBUG("Update config, colorMode: %{public}d", resConfig->GetColorMode());
TAG_LOGD(AAFwkTag::ABILITY, "Update config, colorMode: %{public}d", resConfig->GetColorMode());
}
if (!hasPointerDevice.empty()) {
resConfig->SetInputDevice(AppExecFwk::ConvertHasPointerDevice(hasPointerDevice));
HILOG_DEBUG("Update config, hasPointerDevice: %{public}d", resConfig->GetInputDevice());
TAG_LOGD(AAFwkTag::ABILITY, "Update config, hasPointerDevice: %{public}d", resConfig->GetInputDevice());
}
Global::Resource::RState ret = resourceManager->UpdateResConfig(*resConfig);
if (ret != Global::Resource::RState::SUCCESS) {
HILOG_ERROR("Update resource config failed with %{public}d.", static_cast<int>(ret));
TAG_LOGE(AAFwkTag::ABILITY, "Update resource config failed with %{public}d.", static_cast<int>(ret));
return;
}
HILOG_DEBUG("Update resource config succeed.");
TAG_LOGD(AAFwkTag::ABILITY, "Update resource config succeed.");
}
void ConfigurationUtils::GetGlobalConfig(const Configuration &configuration,
@@ -93,9 +94,9 @@ void ConfigurationUtils::GetGlobalConfig(const Configuration &configuration,
void ConfigurationUtils::InitDisplayConfig(Rosen::DisplayId displayId, std::shared_ptr<Configuration> configuration,
std::shared_ptr<ResourceManager> resourceManager)
{
HILOG_DEBUG("Init display config.");
TAG_LOGD(AAFwkTag::ABILITY, "Init display config.");
if (configuration == nullptr || resourceManager == nullptr) {
HILOG_ERROR("Input invalid.");
TAG_LOGE(AAFwkTag::ABILITY, "Input invalid.");
return;
}
@@ -115,9 +116,9 @@ void ConfigurationUtils::InitDisplayConfig(Rosen::DisplayId displayId, std::shar
void ConfigurationUtils::UpdateDisplayConfig(Rosen::DisplayId displayId, std::shared_ptr<Configuration> configuration,
std::shared_ptr<ResourceManager> resourceManager, bool &configChanged)
{
HILOG_DEBUG("Update display config.");
TAG_LOGD(AAFwkTag::ABILITY, "Update display config.");
if (configuration == nullptr || resourceManager == nullptr) {
HILOG_ERROR("Input invalid.");
TAG_LOGE(AAFwkTag::ABILITY, "Input invalid.");
return;
}
@@ -134,7 +135,7 @@ void ConfigurationUtils::UpdateDisplayConfig(Rosen::DisplayId displayId, std::sh
std::vector<std::string> changeKeyV;
configuration->CompareDifferent(changeKeyV, newConfig);
if (changeKeyV.empty()) {
HILOG_DEBUG("There's no changed config, return.");
TAG_LOGD(AAFwkTag::ABILITY, "There's no changed config, return.");
return;
}
configuration->Merge(changeKeyV, newConfig);
@@ -143,17 +144,18 @@ void ConfigurationUtils::UpdateDisplayConfig(Rosen::DisplayId displayId, std::sh
UpdateDisplayResConfig(resourceManager, density, direction);
auto diffConfiguration = std::make_shared<AppExecFwk::Configuration>(newConfig);
HILOG_INFO("Update display config %{public}s for all windows.", diffConfiguration->GetName().c_str());
TAG_LOGI(AAFwkTag::ABILITY, "Update display config %{public}s for all windows.",
diffConfiguration->GetName().c_str());
Rosen::Window::UpdateConfigurationForAll(diffConfiguration);
}
bool ConfigurationUtils::GetDisplayConfig(Rosen::DisplayId displayId, float &density,
std::string &directionStr)
{
HILOG_DEBUG("Get display by id %{public}" PRIu64".", displayId);
TAG_LOGD(AAFwkTag::ABILITY, "Get display by id %{public}" PRIu64".", displayId);
auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
if (display == nullptr) {
HILOG_ERROR("Get display %{public}" PRIu64" failed.", displayId);
TAG_LOGE(AAFwkTag::ABILITY, "Get display %{public}" PRIu64" failed.", displayId);
return false;
}
@@ -161,8 +163,8 @@ bool ConfigurationUtils::GetDisplayConfig(Rosen::DisplayId displayId, float &den
int32_t width = display->GetWidth();
int32_t height = display->GetHeight();
directionStr = GetDirectionStr(height, width);
HILOG_DEBUG("DisplayId: %{public}" PRIu64", density: %{public}f, direction: %{public}s.", displayId,
density, directionStr.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "DisplayId: %{public}" PRIu64", density: %{public}f, direction: %{public}s.",
displayId, density, directionStr.c_str());
return true;
}
@@ -170,10 +172,11 @@ void ConfigurationUtils::UpdateDisplayResConfig(std::shared_ptr<ResourceManager>
float &density, std::string &direction)
{
// resourceManager has checked in caller function.
HILOG_DEBUG("Update resConfig, density: %{public}f, direction: %{public}s.", density, direction.c_str());
TAG_LOGD(AAFwkTag::ABILITY, "Update resConfig, density: %{public}f, direction: %{public}s.",
density, direction.c_str());
std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
if (resConfig == nullptr) {
HILOG_ERROR("Create resConfig failed.");
TAG_LOGE(AAFwkTag::ABILITY, "Create resConfig failed.");
return;
}
@@ -181,8 +184,8 @@ void ConfigurationUtils::UpdateDisplayResConfig(std::shared_ptr<ResourceManager>
resConfig->SetScreenDensity(density);
resConfig->SetDirection(ConvertDirection(direction));
resourceManager->UpdateResConfig(*resConfig);
HILOG_DEBUG("Update resConfig finished, density: %{public}f, direction: %{public}d.", resConfig->GetScreenDensity(),
resConfig->GetDirection());
TAG_LOGD(AAFwkTag::ABILITY, "Update resConfig finished, density: %{public}f, direction: %{public}d.",
resConfig->GetScreenDensity(), resConfig->GetDirection());
}
#endif
} // namespace AbilityRuntime
frameworks/native/ability/native/recovery/ability_recovery.cpp
+38 -36
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* Copyright (c) 2022-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -24,6 +24,7 @@
#include "app_recovery_parcel_allocator.h"
#include "context/application_context.h"
#include "file_ex.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "js_runtime.h"
#include "js_runtime_utils.h"
@@ -46,9 +47,9 @@ static std::string GetSaveAppCachePath(int32_t savedStateId)
}
std::string fileDir = context->GetFilesDir();
HILOG_DEBUG("AppRecovery GetSaveAppCachePath fileDir %{public}s.", fileDir.c_str());
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery GetSaveAppCachePath fileDir %{public}s.", fileDir.c_str());
if (fileDir.empty() || !OHOS::FileExists(fileDir)) {
HILOG_ERROR("AppRecovery GetSaveAppCachePath fileDir is empty or fileDir is not exists.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery GetSaveAppCachePath fileDir is empty or fileDir is not exists.");
return "";
}
@@ -77,7 +78,7 @@ bool AbilityRecovery::InitAbilityInfo(const std::shared_ptr<AbilityRuntime::UIAb
if (abilityContext != nullptr) {
abilityContext->GetMissionId(missionId_);
}
HILOG_INFO("AppRecovery InitAbilityInfo, missionId_:%{public}d", missionId_);
TAG_LOGI(AAFwkTag::RECOVERY, "AppRecovery InitAbilityInfo, missionId_:%{public}d", missionId_);
return true;
}
@@ -101,18 +102,18 @@ void AbilityRecovery::SetJsAbility(uintptr_t ability)
bool AbilityRecovery::SaveAbilityState()
{
HILOG_DEBUG("SaveAbilityState begin");
TAG_LOGD(AAFwkTag::RECOVERY, "SaveAbilityState begin");
auto ability = ability_.lock();
auto abilityInfo = abilityInfo_.lock();
if (ability == nullptr || abilityInfo == nullptr) {
HILOG_ERROR("AppRecovery ability is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ability is nullptr");
return false;
}
AAFwk::WantParams wantParams;
int32_t status = ability->OnSaveState(AppExecFwk::StateType::APP_RECOVERY, wantParams);
if (!(status == AppExecFwk::OnSaveResult::ALL_AGREE || status == AppExecFwk::OnSaveResult::RECOVERY_AGREE)) {
HILOG_ERROR("AppRecovery Failed to save user params.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery Failed to save user params.");
return false;
}
@@ -121,7 +122,7 @@ bool AbilityRecovery::SaveAbilityState()
if (!pageStack.empty()) {
wantParams.SetParam("pageStack", AAFwk::String::Box(pageStack));
} else {
HILOG_ERROR("AppRecovery Failed to get page stack.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery Failed to get page stack.");
}
#endif
if (saveMode_ == SaveModeFlag::SAVE_WITH_FILE) {
@@ -136,29 +137,30 @@ bool AbilityRecovery::SerializeDataToFile(int32_t savedStateId, WantParams& para
{
std::string file = GetSaveAppCachePath(savedStateId);
if (file.empty()) {
HILOG_ERROR("AppRecovery %{public}s failed to persisted file path.", __func__);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery %{public}s failed to persisted file path.", __func__);
return false;
}
Parcel parcel;
if (!params.Marshalling(parcel)) {
HILOG_ERROR("AppRecovery %{public}s failed to Marshalling want param. ret", __func__);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery %{public}s failed to Marshalling want param. ret", __func__);
return false;
}
int fd = open(file.c_str(), O_RDWR | O_CREAT, (mode_t)0600);
if (fd <= 0) {
HILOG_ERROR("AppRecovery %{public}s failed to open %{public}s.", __func__, file.c_str());
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery %{public}s failed to open %{public}s.", __func__, file.c_str());
return false;
}
size_t sz = parcel.GetDataSize();
uintptr_t buf = parcel.GetData();
if (sz == 0 || buf == 0) {
HILOG_ERROR("AppRecovery %{public}s failed to get parcel data.", __func__);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery %{public}s failed to get parcel data.", __func__);
close(fd);
return false;
}
ssize_t nwrite = write(fd, reinterpret_cast<uint8_t*>(buf), sz);
if (nwrite <= 0) {
HILOG_ERROR("AppRecovery%{public}s failed to persist parcel data %{public}d.", __func__, errno);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery%{public}s failed to persist parcel data %{public}d.",
__func__, errno);
}
close(fd);
return true;
@@ -168,19 +170,19 @@ bool AbilityRecovery::ReadSerializeDataFromFile(int32_t savedStateId, WantParams
{
std::string file = GetSaveAppCachePath(savedStateId);
if (file.empty()) {
HILOG_ERROR("AppRecovery %{public}s failed to persisted file path.", __func__);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery %{public}s failed to persisted file path.", __func__);
return false;
}
char path[PATH_MAX] = {0};
if (realpath(file.c_str(), path) == nullptr) {
HILOG_ERROR("AppRecovery realpath error, errno is %{public}d.", errno);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery realpath error, errno is %{public}d.", errno);
return false;
}
int32_t fd = open(path, O_RDONLY);
if (fd <= 0) {
HILOG_ERROR("AppRecovery fopen error");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery fopen error");
remove(path);
return false;
}
@@ -227,17 +229,17 @@ bool AbilityRecovery::ReadSerializeDataFromFile(int32_t savedStateId, WantParams
bool AbilityRecovery::ScheduleSaveAbilityState(StateReason reason)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery not enable");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not enable");
return false;
}
if (missionId_ <= 0) {
HILOG_ERROR("AppRecovery not save ability missionId_ is invalid");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not save ability missionId_ is invalid");
return false;
}
if (!IsSaveAbilityState(reason)) {
HILOG_ERROR("AppRecovery ts not save ability state");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ts not save ability state");
return false;
}
@@ -245,13 +247,13 @@ bool AbilityRecovery::ScheduleSaveAbilityState(StateReason reason)
if (ret) {
auto token = token_.promote();
if (token == nullptr) {
HILOG_ERROR("AppRecovery token is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery token is nullptr");
return false;
}
std::shared_ptr<AAFwk::AbilityManagerClient> abilityMgr = AAFwk::AbilityManagerClient::GetInstance();
if (abilityMgr == nullptr) {
HILOG_ERROR("AppRecovery ScheduleSaveAbilityState. abilityMgr client is not exist.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleSaveAbilityState. abilityMgr client is not exist.");
return false;
}
abilityMgr->EnableRecoverAbility(token);
@@ -262,13 +264,13 @@ bool AbilityRecovery::ScheduleSaveAbilityState(StateReason reason)
bool AbilityRecovery::ScheduleRecoverAbility(StateReason reason, const Want *want)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery not enable");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not enable");
return false;
}
std::shared_ptr<AAFwk::AbilityManagerClient> abilityMgr = AAFwk::AbilityManagerClient::GetInstance();
if (abilityMgr == nullptr) {
HILOG_ERROR("AppRecovery ScheduleRecoverApp. abilityMgr client is not exist.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRecoverApp. abilityMgr client is not exist.");
return false;
}
@@ -284,11 +286,11 @@ bool AbilityRecovery::PersistState()
{
auto abilityInfo = abilityInfo_.lock();
if (abilityInfo == nullptr) {
HILOG_ERROR("AppRecovery ability is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ability is nullptr");
return false;
}
if (missionId_ <= 0) {
HILOG_ERROR("AppRecovery PersistState missionId is Invalid");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery PersistState missionId is Invalid");
return false;
}
if (!params_.IsEmpty()) {
@@ -304,7 +306,7 @@ bool AbilityRecovery::IsOnForeground()
return false;
}
AbilityLifecycleExecutor::LifecycleState state = ability->GetState();
HILOG_INFO("IsOnForeground state: %{public}d", state);
TAG_LOGI(AAFwkTag::RECOVERY, "IsOnForeground state: %{public}d", state);
if (state == AbilityLifecycleExecutor::LifecycleState::FOREGROUND_NEW) {
return true;
}
@@ -315,7 +317,7 @@ bool AbilityRecovery::LoadSavedState(StateReason reason)
{
auto abilityInfo = abilityInfo_.lock();
if (abilityInfo == nullptr) {
HILOG_ERROR("AppRecovery LoadSavedState abilityInfo is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery LoadSavedState abilityInfo is nullptr");
return false;
}
@@ -323,14 +325,14 @@ bool AbilityRecovery::LoadSavedState(StateReason reason)
return hasLoaded_;
}
if (missionId_ <= 0) {
HILOG_ERROR("AppRecovery LoadSavedState missionId_ is invalid");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery LoadSavedState missionId_ is invalid");
return false;
}
hasTryLoad_ = true;
HILOG_DEBUG("AppRecovery LoadSavedState,missionId_:%{public}d", missionId_);
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery LoadSavedState,missionId_:%{public}d", missionId_);
if (!ReadSerializeDataFromFile(missionId_, params_)) {
HILOG_ERROR("AppRecovery LoadSavedState. failed to find record for id:%{public}d", missionId_);
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery LoadSavedState. failed to find record for id:%{public}d", missionId_);
hasLoaded_ = false;
return hasLoaded_;
}
@@ -346,17 +348,17 @@ bool AbilityRecovery::LoadSavedState(StateReason reason)
bool AbilityRecovery::ScheduleRestoreAbilityState(StateReason reason, const Want &want)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery not enable");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not enable");
return false;
}
if (!IsSaveAbilityState(reason)) {
HILOG_ERROR("AppRecovery ts not save ability state");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ts not save ability state");
return false;
}
if (!LoadSavedState(reason)) {
HILOG_ERROR("AppRecovery ScheduleRestoreAbilityState no saved state ");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRestoreAbilityState no saved state ");
return false;
}
@@ -371,19 +373,19 @@ bool AbilityRecovery::ScheduleRestoreAbilityState(StateReason reason, const Want
std::string AbilityRecovery::GetSavedPageStack(StateReason reason)
{
if (!LoadSavedState(reason)) {
HILOG_ERROR("AppRecovery GetSavedPageStack no saved state ");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery GetSavedPageStack no saved state ");
return "";
}
if (pageStack_.empty()) {
HILOG_ERROR("AppRecovery GetSavedPageStack empty.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery GetSavedPageStack empty.");
}
return pageStack_;
}
bool AbilityRecovery::IsSaveAbilityState(StateReason reason)
{
HILOG_DEBUG("IsSaveAbilityState enter");
TAG_LOGD(AAFwkTag::RECOVERY, "IsSaveAbilityState enter");
bool ret = false;
switch (reason) {
case StateReason::DEVELOPER_REQUEST:
frameworks/native/ability/native/recovery/app_recovery.cpp
+45 -43
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* Copyright (c) 2022-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -29,6 +29,7 @@
#include "context/application_context.h"
#include "directory_ex.h"
#include "file_ex.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "js_runtime.h"
#include "js_runtime_utils.h"
@@ -73,12 +74,12 @@ static bool BlockMainThreadLocked()
action.sa_handler = SigQuitHandler;
action.sa_flags = 0;
if (sigaction(SIGQUIT, &action, nullptr) != 0) {
HILOG_ERROR("AppRecovery Failed to register signal");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery Failed to register signal");
return false;
}
if (syscall(SYS_tgkill, getpid(), getpid(), SIGQUIT) != 0) {
HILOG_ERROR("Failed to send SIGQUIT to main thread, errno(%d).", errno);
TAG_LOGE(AAFwkTag::RECOVERY, "Failed to send SIGQUIT to main thread, errno(%d).", errno);
return false;
}
int left = 1000000; // 1s
@@ -116,12 +117,12 @@ bool AppRecovery::AddAbility(std::shared_ptr<AbilityRuntime::UIAbility> ability,
const std::shared_ptr<AbilityInfo>& abilityInfo, const sptr<IRemoteObject>& token)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery not enabled.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not enabled.");
return false;
}
if (!abilityRecoverys_.empty() && !abilityInfo->recoverable) {
HILOG_ERROR("AppRecovery abilityRecoverys is not empty but ability recoverable is false.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery abilityRecoverys is not empty but ability recoverable is false.");
return false;
}
ability_ = ability;
@@ -136,7 +137,7 @@ bool AppRecovery::AddAbility(std::shared_ptr<AbilityRuntime::UIAbility> ability,
AppRecovery::GetInstance().DeleteInValidMissionFiles();
};
if (!handler->PostTask(task, "AppRecovery:AddAbility", DELAY_TIME)) {
HILOG_ERROR("Failed to DeleteInValidMissionFiles.");
TAG_LOGE(AAFwkTag::RECOVERY, "Failed to DeleteInValidMissionFiles.");
}
}
return true;
@@ -145,48 +146,48 @@ bool AppRecovery::AddAbility(std::shared_ptr<AbilityRuntime::UIAbility> ability,
bool AppRecovery::RemoveAbility(const sptr<IRemoteObject>& tokenId)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery not enabled. not removeAbility");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery not enabled. not removeAbility");
return false;
}
if (!tokenId) {
HILOG_ERROR("AppRecovery removeAbility tokenId is null.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery removeAbility tokenId is null.");
return false;
}
HILOG_DEBUG("AppRecovery removeAbility start");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery removeAbility start");
auto itr = std::find_if(abilityRecoverys_.begin(), abilityRecoverys_.end(),
[&tokenId](std::shared_ptr<AbilityRecovery> &abilityRecovery) {
return (abilityRecovery && abilityRecovery->GetToken() == tokenId);
});
if (itr != abilityRecoverys_.end()) {
abilityRecoverys_.erase(itr);
HILOG_DEBUG("AppRecovery removeAbility done");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery removeAbility done");
}
return true;
}
bool AppRecovery::ScheduleSaveAppState(StateReason reason, uintptr_t ability)
{
HILOG_DEBUG("AppRecovery ScheduleSaveAppState begin");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery ScheduleSaveAppState begin");
if (!isEnable_) {
HILOG_ERROR("AppRecovery ScheduleSaveAppState. is not enabled");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleSaveAppState. is not enabled");
return false;
}
if (!ShouldSaveAppState(reason)) {
HILOG_ERROR("AppRecovery ts not save ability state");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ts not save ability state");
return false;
}
if (reason == StateReason::APP_FREEZE) {
auto abilityPtr = ability_.lock();
if (!abilityPtr || !abilityPtr->GetAbilityContext()) {
HILOG_ERROR("AppRecovery ScheduleSaveAppState ability or context is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleSaveAppState ability or context is nullptr");
return false;
}
std::lock_guard<std::mutex> lock(g_mutex);
if (!BlockMainThreadLocked()) {
HILOG_ERROR("AppRecovery Failed to block main thread, skip save state when appfreeze");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery Failed to block main thread, skip save state when appfreeze");
return false;
}
OHOS::AbilityRuntime::JsUIAbility& jsAbility = static_cast<AbilityRuntime::JsUIAbility&>(*abilityPtr);
@@ -199,7 +200,7 @@ bool AppRecovery::ScheduleSaveAppState(StateReason reason, uintptr_t ability)
auto handler = mainHandler_.lock();
if (handler == nullptr) {
HILOG_ERROR("ScheduleSaveAppState. main handler is not exist");
TAG_LOGE(AAFwkTag::RECOVERY, "ScheduleSaveAppState. main handler is not exist");
return false;
}
@@ -207,7 +208,7 @@ bool AppRecovery::ScheduleSaveAppState(StateReason reason, uintptr_t ability)
AppRecovery::GetInstance().DoSaveAppState(reason, ability);
};
if (!handler->PostTask(task, "AppRecovery:SaveAppState")) {
HILOG_ERROR("Failed to schedule save app state.");
TAG_LOGE(AAFwkTag::RECOVERY, "Failed to schedule save app state.");
return false;
}
@@ -216,9 +217,9 @@ bool AppRecovery::ScheduleSaveAppState(StateReason reason, uintptr_t ability)
void AppRecovery::SetRestartWant(std::shared_ptr<AAFwk::Want> want)
{
HILOG_DEBUG("AppRecovery SetRestartWant begin");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery SetRestartWant begin");
if (!isEnable_) {
HILOG_ERROR("AppRecovery SetRestartWant not enabled");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery SetRestartWant not enabled");
return;
}
want_ = want;
@@ -227,17 +228,17 @@ void AppRecovery::SetRestartWant(std::shared_ptr<AAFwk::Want> want)
bool AppRecovery::ScheduleRecoverApp(StateReason reason)
{
if (!isEnable_) {
HILOG_ERROR("AppRecovery ScheduleRecoverApp. is not enabled");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRecoverApp. is not enabled");
return false;
}
if (!ShouldRecoverApp(reason)) {
HILOG_ERROR("AppRecovery ScheduleRecoverApp. is not recover app");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRecoverApp. is not recover app");
return false;
}
if (abilityRecoverys_.empty()) {
HILOG_ERROR("AppRecovery ScheduleRecoverApp ability is nullptr");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRecoverApp ability is nullptr");
return false;
}
@@ -248,7 +249,7 @@ bool AppRecovery::ScheduleRecoverApp(StateReason reason)
auto handler = mainHandler_.lock();
if (handler == nullptr) {
HILOG_ERROR("AppRecovery ScheduleRecoverApp main handler is not exist");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery ScheduleRecoverApp main handler is not exist");
return false;
}
@@ -261,7 +262,7 @@ bool AppRecovery::ScheduleRecoverApp(StateReason reason)
AppRecovery::GetInstance().DoRecoverApp(reason);
};
if (!handler->PostTask(task, "AppRecovery:RecoverApp")) {
HILOG_ERROR("Failed to schedule save app state.");
TAG_LOGE(AAFwkTag::RECOVERY, "Failed to schedule save app state.");
}
return true;
@@ -280,9 +281,9 @@ bool AppRecovery::TryRecoverApp(StateReason reason)
void AppRecovery::DoRecoverApp(StateReason reason)
{
HILOG_DEBUG("AppRecovery DoRecoverApp begin");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery DoRecoverApp begin");
if (abilityRecoverys_.empty()) {
HILOG_ERROR("AppRecovery no ability exist! ");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery no ability exist! ");
return;
}
AAFwk::Want *want = nullptr;
@@ -303,15 +304,15 @@ void AppRecovery::DoRecoverApp(StateReason reason)
break;
}
}
HILOG_WARN("AppRecovery no foreground ability, not DoRecoverApp!");
TAG_LOGW(AAFwkTag::RECOVERY, "AppRecovery no foreground ability, not DoRecoverApp!");
}
void AppRecovery::DoSaveAppState(StateReason reason, uintptr_t ability)
{
HILOG_DEBUG("AppRecovery DoSaveAppState begin");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery DoSaveAppState begin");
auto appInfo = applicationInfo_.lock();
if (appInfo == nullptr || abilityRecoverys_.empty()) {
HILOG_ERROR("AppRecovery Application or ability info is not exist.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery Application or ability info is not exist.");
return;
}
@@ -319,12 +320,12 @@ void AppRecovery::DoSaveAppState(StateReason reason, uintptr_t ability)
for (auto& abilityRecoveryRecord : abilityRecoverys_) {
if (!onlySaveTargetAbility) {
abilityRecoveryRecord->ScheduleSaveAbilityState(reason);
HILOG_DEBUG("AppRecovery not onlySaveTargetAbility ScheduleSaveAbilityState");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery not onlySaveTargetAbility ScheduleSaveAbilityState");
continue;
}
if (abilityRecoveryRecord->IsSameAbility(ability)) {
abilityRecoveryRecord->ScheduleSaveAbilityState(reason);
HILOG_DEBUG("AppRecovery IsSameAbility ScheduleSaveAbilityState");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery IsSameAbility ScheduleSaveAbilityState");
break;
}
}
@@ -410,35 +411,36 @@ void AppRecovery::DeleteInValidMissionFiles()
}
std::string fileDir = context->GetFilesDir();
HILOG_DEBUG("AppRecovery DeleteInValidMissionFiles fileDir: %{public}s", fileDir.c_str());
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery DeleteInValidMissionFiles fileDir: %{public}s", fileDir.c_str());
if (fileDir.empty() || !OHOS::FileExists(fileDir)) {
HILOG_DEBUG("AppRecovery DeleteInValidMissionFiles fileDir is empty or fileDir is not exists.");
TAG_LOGD(AAFwkTag::RECOVERY,
"AppRecovery DeleteInValidMissionFiles fileDir is empty or fileDir is not exists.");
return;
}
std::vector<int32_t> missionIds;
std::vector<MissionValidResult> results;
if (!GetMissionIds(fileDir, missionIds)) {
HILOG_ERROR("AppRecovery get mssion file id error.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery get mssion file id error.");
return;
}
if (missionIds.empty()) {
HILOG_DEBUG("AppRecovery no mission file, no need delete it.");
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery no mission file, no need delete it.");
return;
}
std::shared_ptr<AAFwk::AbilityManagerClient> abilityMgr = AAFwk::AbilityManagerClient::GetInstance();
if (abilityMgr == nullptr) {
HILOG_ERROR("AppRecovery DeleteInValidMissionFiles. abilityMgr client is not exist.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery DeleteInValidMissionFiles. abilityMgr client is not exist.");
return;
}
abilityMgr->IsValidMissionIds(missionIds, results);
if (results.empty()) {
HILOG_ERROR("AppRecovery DeleteInValidMissionFiles. results is empty.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery DeleteInValidMissionFiles. results is empty.");
return;
}
for (auto& item : results) {
HILOG_INFO("AppRecovery missionResult: missionId: %{public}d, isValid: %{public}d", item.missionId,
item.isValid);
TAG_LOGI(AAFwkTag::RECOVERY, "AppRecovery missionResult: missionId: %{public}d, isValid: %{public}d",
item.missionId, item.isValid);
if (!item.isValid) {
DeleteInValidMissionFileById(fileDir, item.missionId);
}
@@ -451,22 +453,22 @@ void AppRecovery::DeleteInValidMissionFileById(std::string fileDir, int32_t miss
std::string file = fileDir + "/" + fileName;
bool ret = OHOS::RemoveFile(file);
if (!ret) {
HILOG_ERROR("AppRecovery delete the file: %{public}s failed", file.c_str());
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery delete the file: %{public}s failed", file.c_str());
}
HILOG_DEBUG("AppRecovery delete the file: %{public}s done", file.c_str());
TAG_LOGD(AAFwkTag::RECOVERY, "AppRecovery delete the file: %{public}s done", file.c_str());
}
bool AppRecovery::GetMissionIds(std::string path, std::vector<int32_t> &missionIds)
{
DIR *dir = opendir(path.c_str());
if (dir == nullptr) {
HILOG_ERROR("AppRecovery GetMissionIds open dir error.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery GetMissionIds open dir error.");
return false;
}
struct dirent *ptr;
while ((ptr = readdir(dir)) != nullptr) {
if (ptr == nullptr) {
HILOG_ERROR("AppRecovery GetMissionIds read dir error.");
TAG_LOGE(AAFwkTag::RECOVERY, "AppRecovery GetMissionIds read dir error.");
return false;
}
if (strcmp(ptr->d_name, ".") == 0 || strcmp(ptr->d_name, "..") == 0) {
interfaces/inner_api/app_manager/src/appmgr/ability_controller_proxy.cpp
+6 -5
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -15,6 +15,7 @@
#include "ability_controller_proxy.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "ipc_types.h"
@@ -28,7 +29,7 @@ AbilityControllerProxy::AbilityControllerProxy(
bool AbilityControllerProxy::WriteInterfaceToken(MessageParcel &data)
{
if (!data.WriteInterfaceToken(AbilityControllerProxy::GetDescriptor())) {
HILOG_ERROR("write interface token failed");
TAG_LOGE(AAFwkTag::APPMGR, "write interface token failed");
return false;
}
return true;
@@ -48,7 +49,7 @@ bool AbilityControllerProxy::AllowAbilityStart(const Want &want, const std::stri
static_cast<uint32_t>(IAbilityController::Message::TRANSACT_ON_ALLOW_ABILITY_START),
data, reply, option);
if (ret != NO_ERROR) {
HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
TAG_LOGW(AAFwkTag::APPMGR, "SendRequest is failed, error code: %{public}d", ret);
return true;
}
return reply.ReadBool();
@@ -67,7 +68,7 @@ bool AbilityControllerProxy::AllowAbilityBackground(const std::string &bundleNam
static_cast<uint32_t>(IAbilityController::Message::TRANSACT_ON_ALLOW_ABILITY_BACKGROUND),
data, reply, option);
if (ret != NO_ERROR) {
HILOG_WARN("SendRequest is failed, error code: %{public}d", ret);
TAG_LOGW(AAFwkTag::APPMGR, "SendRequest is failed, error code: %{public}d", ret);
return true;
}
return reply.ReadBool();
@@ -78,7 +79,7 @@ int32_t AbilityControllerProxy::SendTransactCmd(uint32_t code, MessageParcel &da
{
sptr<IRemoteObject> remote = Remote();
if (remote == nullptr) {
HILOG_ERROR("Remote is nullptr.");
TAG_LOGE(AAFwkTag::APPMGR, "Remote is nullptr.");
return ERR_NULL_OBJECT;
}
interfaces/inner_api/app_manager/src/appmgr/ability_controller_stub.cpp
+9 -7
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Copyright (c) 2021-2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
@@ -15,6 +15,7 @@
#include "ability_controller_stub.h"
#include "appexecfwk_errors.h"
#include "hilog_tag_wrapper.h"
#include "hilog_wrapper.h"
#include "ipc_types.h"
#include "iremote_object.h"
@@ -39,11 +40,12 @@ AbilityControllerStub::~AbilityControllerStub()
int AbilityControllerStub::OnRemoteRequest(
uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
HILOG_INFO("AbilityControllerStub::OnReceived, code = %{public}u, flags= %{public}d.", code, option.GetFlags());
TAG_LOGI(AAFwkTag::APPMGR, "AbilityControllerStub::OnReceived, code = %{public}u, flags= %{public}d.", code,
option.GetFlags());
std::u16string descriptor = AbilityControllerStub::GetDescriptor();
std::u16string remoteDescriptor = data.ReadInterfaceToken();
if (descriptor != remoteDescriptor) {
HILOG_ERROR("local descriptor is unequal to remote.");
TAG_LOGE(AAFwkTag::APPMGR, "local descriptor is unequal to remote.");
return ERR_INVALID_STATE;
}
@@ -54,7 +56,7 @@ int AbilityControllerStub::OnRemoteRequest(
return (this->*memberFunc)(data, reply);
}
}
HILOG_INFO("AbilityControllerStub::OnRemoteRequest finish");
TAG_LOGI(AAFwkTag::APPMGR, "AbilityControllerStub::OnRemoteRequest finish");
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
@@ -70,10 +72,10 @@ bool AbilityControllerStub::AllowAbilityBackground(const std::string &bundleName
int32_t AbilityControllerStub::HandleAllowAbilityStart(MessageParcel &data, MessageParcel &reply)
{
HILOG_INFO("HandleAllowAbilityStart");
TAG_LOGI(AAFwkTag::APPMGR, "HandleAllowAbilityStart");
std::unique_ptr<Want> want(data.ReadParcelable<Want>());
if (!want) {
HILOG_ERROR("ReadParcelable<Want> failed");
TAG_LOGE(AAFwkTag::APPMGR, "ReadParcelable<Want> failed");
return ERR_APPEXECFWK_PARCEL_ERROR;
}
std::string pkg = data.ReadString();
@@ -84,7 +86,7 @@ int32_t AbilityControllerStub::HandleAllowAbilityStart(MessageParcel &data, Mess
int32_t AbilityControllerStub::HandleAllowAbilityBackground(MessageParcel &data, MessageParcel &reply)
{
HILOG_INFO("HandleAllowAbilityBackground");
TAG_LOGI(AAFwkTag::APPMGR, "HandleAllowAbilityBackground");
std::string pkg = data.ReadString();
bool ret = AllowAbilityBackground(pkg);
reply.WriteBool(ret);