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

Description: ServiceExtension 支持call调用

Browse Source 
Sig:SIG_ApplicaitonFramework
Feature or Bugfix:Feature
Binary Source:No

Signed-off-by: HuangXW <huangxinwei4@huawei.com>
This commit is contained in:
HuangXW 2022-07-28 22:00:06 +08:00
parent 6649e1bbf0
commit e8f047eb78
12 changed files with 310 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
frameworks/js/napi/service_extension_context/service_extension_context.js
View File

@ -14,6 +14,7 @@
*/
var ExtensionContext = requireNapi("application.ExtensionContext")
var Caller = requireNapi("application.Caller")
class ServiceExtensionContext extends ExtensionContext {
constructor(obj) {
@ -69,6 +70,27 @@ class ServiceExtensionContext extends ExtensionContext {
console.log("terminateSelf");
return this.__context_impl__.terminateSelf(callback);
}
startAbilityByCall(want) {
return new Promise(async (resolve, reject) => {
if (typeof want !== 'object' || want == null) {
console.log("ServiceExtensionContext::startAbilityByCall input param error");
reject(new Error("function input parameter error"));
return;
}
let callee = await this.__context_impl__.startAbilityByCall(want);
if (callee == null || typeof callee !== 'object') {
console.log("ServiceExtensionContext::startAbilityByCall Obtain remoteObject failed");
reject(new Error("function request remote error"));
return;
}
resolve(new Caller(callee));
console.log("ServiceExtensionContext::startAbilityByCall success");
return;
});
}
}
export default ServiceExtensionContext

15
frameworks/native/ability/ability_runtime/local_call_container.cpp
View File

@ -59,7 +59,15 @@ int LocalCallContainer::StartAbilityByCallInner(
HILOG_DEBUG("start ability by call, localCallRecord->AddCaller(callback) end");
auto remote = localCallRecord->GetRemoteObject();
if (remote == nullptr) {
// already finish call request.
if (remote) {
HILOG_DEBUG("start ability by call, callback->InvokeCallBack(remote) begin");
callback->InvokeCallBack(remote);
HILOG_DEBUG("start ability by call, callback->InvokeCallBack(remote) end");
if (!want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
return ERR_OK;
}
}
auto abilityClient = AAFwk::AbilityManagerClient::GetInstance();
if (abilityClient == nullptr) {
HILOG_ERROR("LocalCallContainer::Resolve abilityClient is nullptr");
@ -68,11 +76,6 @@ int LocalCallContainer::StartAbilityByCallInner(
sptr<IAbilityConnection> connect = iface_cast<IAbilityConnection>(this->AsObject());
HILOG_DEBUG("start ability by call, abilityClient->StartAbilityByCall call");
return abilityClient->StartAbilityByCall(want, connect, callerToken);
}
// already finish call request.
HILOG_DEBUG("start ability by call, callback->InvokeCallBack(remote) begin");
callback->InvokeCallBack(remote);
HILOG_DEBUG("start ability by call, callback->InvokeCallBack(remote) end");
return ERR_OK;
}

11
frameworks/native/ability/native/ability_runtime/js_ability_context.cpp
View File

@ -328,8 +328,17 @@ NativeValue* JsAbilityContext::OnStartAbilityByCall(NativeEngine& engine, Native
auto context = weak.lock();
if (context != nullptr && calldata->callerCallBack != nullptr && calldata->remoteCallee != nullptr) {
auto releaseAbilityFunc = [weak] (
const std::shared_ptr<CallerCallBack> &callback) -> ErrCode {
auto contextForRelease = weak.lock();
if (contextForRelease == nullptr) {
HILOG_ERROR("releaseAbilityFunction, context is nullptr");
return -1;
}
return contextForRelease->ReleaseAbility(callback);
};
task.Resolve(engine,
CreateJsCallerComplex(engine, context, calldata->remoteCallee, calldata->callerCallBack));
CreateJsCallerComplex(engine, releaseAbilityFunc, calldata->remoteCallee, calldata->callerCallBack));
} else {
HILOG_ERROR("OnStartAbilityByCall callComplete params error %{public}s is nullptr",
context == nullptr ? "context" :

25
frameworks/native/ability/native/ability_runtime/js_caller_complex.cpp
View File

@ -49,8 +49,8 @@ public:
};
explicit JsCallerComplex(
NativeEngine& engine, std::shared_ptr<AbilityContext> context, sptr<IRemoteObject> callee,
std::shared_ptr<CallerCallBack> callerCallBack) : context_(context), callee_(callee),
NativeEngine& engine, ReleaseAbilityFunc releaseAbilityFunc, sptr<IRemoteObject> callee,
std::shared_ptr<CallerCallBack> callerCallBack) : releaseAbilityFunc_(releaseAbilityFunc), callee_(callee),
releaseCallBackEngine_(engine), callerCallBackObj_(callerCallBack), jsreleaseCallBackObj_(nullptr)
{
AddJsCallerComplex(this);
@ -316,13 +316,11 @@ private:
return CreateJsError(engine, -1, "CallerComplex callback is nullptr.");
}
auto context = context_.lock();
if (context == nullptr) {
HILOG_ERROR("JsCallerComplex::%{public}s, context is nullptr", __func__);
return CreateJsError(engine, -1, "CallerComplex get context failed.");
if (!releaseAbilityFunc_) {
HILOG_ERROR("JsCallerComplex::%{public}s, releaseFunc is nullptr", __func__);
return CreateJsError(engine, -1, "CallerComplex get releaseFunc failed.");
}
auto retErr = context->ReleaseAbility(callerCallBackObj_);
int32_t retErr = releaseAbilityFunc_(callerCallBackObj_);
if (retErr != ERR_OK) {
HILOG_ERROR("JsCallerComplex::%{public}s, ReleaseAbility failed %{public}d",
__func__, static_cast<int>(retErr));
@ -371,7 +369,7 @@ private:
}
private:
std::weak_ptr<AbilityContext> context_;
ReleaseAbilityFunc releaseAbilityFunc_;
sptr<IRemoteObject> callee_;
NativeEngine& releaseCallBackEngine_;
std::shared_ptr<CallerCallBack> callerCallBackObj_;
@ -389,20 +387,21 @@ std::mutex JsCallerComplex::jsCallerComplexMutex;
} // nameless
NativeValue* CreateJsCallerComplex(
NativeEngine& engine, std::shared_ptr<AbilityContext> context, sptr<IRemoteObject> callee,
NativeEngine& engine, ReleaseAbilityFunc releaseAbilityFunc, sptr<IRemoteObject> callee,
std::shared_ptr<CallerCallBack> callerCallBack)
{
HILOG_DEBUG("JsCallerComplex::%{public}s, begin", __func__);
if (callee == nullptr || callerCallBack == nullptr || context == nullptr) {
if (callee == nullptr || callerCallBack == nullptr || releaseAbilityFunc == nullptr) {
HILOG_ERROR("%{public}s is called, input params error. %{public}s is nullptr", __func__,
(callee == nullptr) ? ("callee") : ((context == nullptr) ? ("context") : ("callerCallBack")));
(callee == nullptr) ? ("callee") :
((releaseAbilityFunc == nullptr) ? ("releaseAbilityFunc") : ("callerCallBack")));
return engine.CreateUndefined();
}
NativeValue* objValue = engine.CreateObject();
NativeObject* object = ConvertNativeValueTo<NativeObject>(objValue);
auto jsCaller = std::make_unique<JsCallerComplex>(engine, context, callee, callerCallBack);
auto jsCaller = std::make_unique<JsCallerComplex>(engine, releaseAbilityFunc, callee, callerCallBack);
if (jsCaller == nullptr) {
HILOG_ERROR("%{public}s is called, but make_unique<JsCallerComplex> is nullptr", __func__);
return engine.CreateUndefined();

159
frameworks/native/ability/native/js_service_extension_context.cpp
View File

@ -17,6 +17,7 @@
#include <cstdint>
#include "ability_runtime/js_caller_complex.h"
#include "hilog_wrapper.h"
#include "js_extension_context.h"
#include "js_data_struct_converter.h"
@ -45,6 +46,15 @@ constexpr size_t ARGC_THREE = 3;
constexpr size_t ARGC_FOUR = 4;
constexpr int32_t ERR_NOT_OK = -1;
class StartAbilityByCallParameters {
public:
int err = 0;
sptr<IRemoteObject> remoteCallee = nullptr;
std::shared_ptr<CallerCallBack> callerCallBack = nullptr;
std::mutex mutexlock;
std::condition_variable condition;
};
class JsServiceExtensionContext final {
public:
explicit JsServiceExtensionContext(const std::shared_ptr<ServiceExtensionContext>& context) : context_(context) {}
@ -62,6 +72,12 @@ public:
return (me != nullptr) ? me->OnStartAbility(*engine, *info) : nullptr;
}
static NativeValue* StartAbilityByCall(NativeEngine* engine, NativeCallbackInfo* info)
{
JsServiceExtensionContext* me = CheckParamsAndGetThis<JsServiceExtensionContext>(engine, info);
return (me != nullptr) ? me->OnStartAbilityByCall(*engine, *info) : nullptr;
}
static NativeValue* StartAbilityWithAccount(NativeEngine* engine, NativeCallbackInfo* info)
{
JsServiceExtensionContext* me = CheckParamsAndGetThis<JsServiceExtensionContext>(engine, info);
@ -115,6 +131,7 @@ public:
JsServiceExtensionContext* me = CheckParamsAndGetThis<JsServiceExtensionContext>(engine, info);
return (me != nullptr) ? me->OnStopExtensionAbilityWithAccount(*engine, *info) : nullptr;
}
private:
std::weak_ptr<ServiceExtensionContext> context_;
NativeValue* OnStartAbility(NativeEngine& engine, NativeCallbackInfo& info)
@ -166,11 +183,138 @@ private:
NativeValue* lastParam = (info.argc == unwrapArgc) ? nullptr : info.argv[unwrapArgc];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStartAbility",
AsyncTask::Schedule("JSServiceExtensionContext::OnStartAbility",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
NativeValue* OnStartAbilityByCall(NativeEngine& engine, NativeCallbackInfo& info)
{
HILOG_INFO("OnStartAbilityByCall is called.");
constexpr size_t ARGC_ONE = 1;
constexpr size_t ARGC_TWO = 2;
if (info.argc < ARGC_ONE || info.argv[0]->TypeOf() != NATIVE_OBJECT) {
HILOG_ERROR("int put params count error");
return engine.CreateUndefined();
}
AAFwk::Want want;
OHOS::AppExecFwk::UnwrapWant(reinterpret_cast<napi_env>(&engine),
reinterpret_cast<napi_value>(info.argv[0]), want);
std::shared_ptr<StartAbilityByCallParameters> calls = std::make_shared<StartAbilityByCallParameters>();
if (calls == nullptr) {
HILOG_ERROR("calls create error");
return engine.CreateUndefined();
}
NativeValue* lastParam = ((info.argc == ARGC_TWO) ? info.argv[ARGC_ONE] : nullptr);
NativeValue* retsult = nullptr;
calls->callerCallBack = std::make_shared<CallerCallBack>();
calls->callerCallBack->SetCallBack(GetCallBackDone(calls));
calls->callerCallBack->SetOnRelease(GetReleaseListen());
auto context = context_.lock();
if (context == nullptr) {
HILOG_ERROR("OnStartAbilityByCall context is nullptr");
return engine.CreateUndefined();
}
if (context->StartAbilityByCall(want, calls->callerCallBack) != 0) {
HILOG_ERROR("OnStartAbilityByCall StartAbility is failed");
return engine.CreateUndefined();
}
if (calls->remoteCallee == nullptr) {
HILOG_INFO("OnStartAbilityByCall async wait execute");
AsyncTask::Schedule("JsAbilityContext::OnStartAbilityByCall", engine,
CreateAsyncTaskWithLastParam(
engine, lastParam, GetCallExecute(calls), GetCallComplete(calls), &retsult));
} else {
HILOG_INFO("OnStartAbilityByCall promiss return result execute");
AsyncTask::Schedule("JSServiceExtensionContext::OnStartAbilityByCall", engine,
CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, GetCallComplete(calls), &retsult));
}
return retsult;
}
AsyncTask::CompleteCallback GetCallComplete(std::shared_ptr<StartAbilityByCallParameters> calls)
{
auto callComplete = [weak = context_, calldata = calls] (
NativeEngine& engine, AsyncTask& task, int32_t status) {
if (calldata->err != 0) {
HILOG_ERROR("OnStartAbilityByCall callComplete err is %{public}d", calldata->err);
task.Reject(engine, CreateJsError(engine, calldata->err, "callComplete err."));
return;
}
auto context = weak.lock();
if (context != nullptr && calldata->callerCallBack != nullptr && calldata->remoteCallee != nullptr) {
auto releaseAbilityFunc = [weak] (
const std::shared_ptr<CallerCallBack> &callback) -> ErrCode {
auto contextForRelease = weak.lock();
if (contextForRelease == nullptr) {
HILOG_ERROR("releaseAbilityFunction, context is nullptr");
return -1;
}
return contextForRelease->ReleaseAbility(callback);
};
task.Resolve(engine,
CreateJsCallerComplex(
engine, releaseAbilityFunc, calldata->remoteCallee, calldata->callerCallBack));
} else {
HILOG_ERROR("OnStartAbilityByCall callComplete params error %{public}s is nullptr",
context == nullptr ? "context" :
(calldata->remoteCallee == nullptr ? "remoteCallee" : "callerCallBack"));
task.Reject(engine, CreateJsError(engine, -1, "Create Call Failed."));
}
HILOG_DEBUG("OnStartAbilityByCall callComplete end");
};
return callComplete;
}
AsyncTask::ExecuteCallback GetCallExecute(std::shared_ptr<StartAbilityByCallParameters> calls)
{
auto callExecute = [calldata = calls] () {
constexpr int CALLER_TIME_OUT = 10; // 10s
std::unique_lock<std::mutex> lock(calldata->mutexlock);
if (calldata->remoteCallee != nullptr) {
HILOG_INFO("OnStartAbilityByCall callExecute callee isn`t nullptr");
return;
}
if (calldata->condition.wait_for(lock, std::chrono::seconds(CALLER_TIME_OUT)) == std::cv_status::timeout) {
HILOG_ERROR("OnStartAbilityByCall callExecute waiting callee timeout");
calldata->err = -1;
}
HILOG_DEBUG("OnStartAbilityByCall callExecute end");
};
return callExecute;
}
CallerCallBack::CallBackClosure GetCallBackDone(std::shared_ptr<StartAbilityByCallParameters> calls)
{
auto callBackDone = [calldata = calls] (const sptr<IRemoteObject> &obj) {
HILOG_DEBUG("OnStartAbilityByCall callBackDone mutexlock");
std::unique_lock<std::mutex> lock(calldata->mutexlock);
HILOG_DEBUG("OnStartAbilityByCall callBackDone remoteCallee assignment");
calldata->remoteCallee = obj;
calldata->condition.notify_all();
HILOG_INFO("OnStartAbilityByCall callBackDone is called end");
};
return callBackDone;
}
CallerCallBack::OnReleaseClosure GetReleaseListen()
{
auto releaseListen = [](const std::string &str) {
HILOG_INFO("OnStartAbilityByCall releaseListen is called %{public}s", str.c_str());
};
return releaseListen;
}
NativeValue* OnStartAbilityWithAccount(NativeEngine& engine, NativeCallbackInfo& info)
{
HILOG_INFO("OnStartAbilityWithAccount is called");
@ -230,7 +374,7 @@ private:
NativeValue* lastParam = (info.argc == unwrapArgc) ? nullptr : info.argv[unwrapArgc];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStartAbilityWithAccount",
AsyncTask::Schedule("JSServiceExtensionContext::OnStartAbilityWithAccount",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -264,7 +408,7 @@ private:
NativeValue* lastParam = (info.argc == ARGC_ZERO) ? nullptr : info.argv[INDEX_ZERO];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnTerminateAbility",
AsyncTask::Schedule("JSServiceExtensionContext::OnTerminateAbility",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -476,7 +620,7 @@ private:
NativeValue* lastParam = (info.argc <= ARGC_ONE) ? nullptr : info.argv[ARGC_ONE];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStartExtensionAbility",
AsyncTask::Schedule("JSServiceExtensionContext::OnStartExtensionAbility",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -523,7 +667,7 @@ private:
NativeValue* lastParam = (info.argc <= ARGC_TWO) ? nullptr : info.argv[ARGC_TWO];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStartExtensionAbilityWithAccount",
AsyncTask::Schedule("JSServiceExtensionContext::OnStartExtensionAbilityWithAccount",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -564,7 +708,7 @@ private:
NativeValue* lastParam = (info.argc <= ARGC_ONE) ? nullptr : info.argv[ARGC_ONE];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStopExtensionAbility",
AsyncTask::Schedule("JSServiceExtensionContext::OnStopExtensionAbility",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -611,7 +755,7 @@ private:
NativeValue* lastParam = (info.argc <= ARGC_TWO) ? nullptr : info.argv[ARGC_TWO];
NativeValue* result = nullptr;
AsyncTask::Schedule("JSServiceExtensionConnection::OnStopExtensionAbilityWithAccount",
AsyncTask::Schedule("JSServiceExtensionContext::OnStopExtensionAbilityWithAccount",
engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
return result;
}
@ -664,6 +808,7 @@ NativeValue* CreateJsServiceExtensionContext(NativeEngine& engine, std::shared_p
BindNativeFunction(engine, *object, "connectAbility", JsServiceExtensionContext::ConnectAbility);
BindNativeFunction(engine, *object, "disconnectAbility", JsServiceExtensionContext::DisconnectAbility);
BindNativeFunction(engine, *object, "startAbilityWithAccount", JsServiceExtensionContext::StartAbilityWithAccount);
BindNativeFunction(engine, *object, "startAbilityByCall", JsServiceExtensionContext::StartAbilityByCall);
BindNativeFunction(
engine, *object, "connectAbilityWithAccount", JsServiceExtensionContext::ConnectAbilityWithAccount);
BindNativeFunction(engine, *object, "startServiceExtensionAbility",

24
frameworks/native/appkit/ability_runtime/service_extension_context.cpp
View File

@ -48,6 +48,30 @@ ErrCode ServiceExtensionContext::StartAbility(const AAFwk::Want &want, const AAF
return err;
}
ErrCode ServiceExtensionContext::StartAbilityByCall(
const AAFwk::Want& want, const std::shared_ptr<CallerCallBack> &callback)
{
HILOG_DEBUG("%{public}s begin.", __func__);
if (localCallContainer_ == nullptr) {
localCallContainer_ = new (std::nothrow) LocalCallContainer();
if (localCallContainer_ == nullptr) {
HILOG_ERROR("%{public}s failed, localCallContainer_ is nullptr.", __func__);
return ERR_INVALID_VALUE;
}
}
return localCallContainer_->StartAbilityByCallInner(want, callback, token_);
}
ErrCode ServiceExtensionContext::ReleaseAbility(const std::shared_ptr<CallerCallBack> &callback) const
{
HILOG_DEBUG("%{public}s begin.", __func__);
if (localCallContainer_ == nullptr) {
HILOG_ERROR("%{public}s failed, localCallContainer_ is nullptr.", __func__);
return ERR_INVALID_VALUE;
}
return localCallContainer_->Release(callback);
}
bool ServiceExtensionContext::ConnectAbility(
const AAFwk::Want &want, const sptr<AbilityConnectCallback> &connectCallback) const
{

5
interfaces/kits/native/ability/native/ability_runtime/js_caller_complex.h
View File

@ -16,6 +16,7 @@
#define OHOS_ABILITY_RUNTIME_JS_CALLER_COMPLEX_H
#include <memory>
#include <functional>
#include <native_engine/native_value.h>
#include "iremote_object.h"
@ -23,8 +24,10 @@
namespace OHOS {
namespace AbilityRuntime {
using ReleaseAbilityFunc = std::function<ErrCode(std::shared_ptr<CallerCallBack>&)>;
NativeValue* CreateJsCallerComplex(
NativeEngine& engine, std::shared_ptr<AbilityContext> context, sptr<IRemoteObject> callee,
NativeEngine& engine, ReleaseAbilityFunc releaseAbilityFunc, sptr<IRemoteObject> callee,
std::shared_ptr<CallerCallBack> callerCallBack);
NativeValue* CreateJsCalleeRemoteObject(NativeEngine& engine, sptr<IRemoteObject> callee);

21
interfaces/kits/native/appkit/ability_runtime/service_extension_context.h
View File

@ -20,6 +20,7 @@
#include "ability_connect_callback.h"
#include "connection_manager.h"
#include "local_call_container.h"
#include "start_options.h"
#include "want.h"
@ -48,6 +49,25 @@ public:
ErrCode StartAbility(const AAFwk::Want &want, const AAFwk::StartOptions &startOptions) const;
/**
* call function by callback object
*
* @param want Request info for ability.
* @param callback Indicates the callback object.
*
* @return Returns zero on success, others on failure.
*/
ErrCode StartAbilityByCall(const AAFwk::Want& want, const std::shared_ptr<CallerCallBack> &callback);
/**
* caller release by callback object
*
* @param callback Indicates the callback object.
*
* @return Returns zero on success, others on failure.
*/
ErrCode ReleaseAbility(const std::shared_ptr<CallerCallBack> &callback) const;
/**
* @brief Connects the current ability to an ability using the AbilityInfo.AbilityType.SERVICE template.
*
@ -123,6 +143,7 @@ protected:
private:
static int ILLEGAL_REQUEST_CODE;
sptr<LocalCallContainer> localCallContainer_ = nullptr;
/**
* @brief Get Current Ability Type

3
services/abilitymgr/include/ability_record.h
View File

@ -787,6 +787,8 @@ public:
bool CallRequest();
bool IsStartToBackground() const;
void SetStartToBackground(const bool flag);
bool IsStartToForeground() const;
void SetStartToForeground(const bool flag);
void SetMinimizeReason(bool fromUser);
bool IsMinimizeFromUser() const;
void SetClearMissionFlag(bool clearMissionFlag);
@ -924,6 +926,7 @@ private:
std::shared_ptr<CallContainer> callContainer_ = nullptr;
bool isStartedByCall_ = false;
bool isStartToBackground_ = false;
bool isStartToForeground_ = false;
int32_t appIndex_ = 0;
bool minimizeReason_ = false;

10
services/abilitymgr/src/ability_record.cpp
View File

@ -1733,6 +1733,16 @@ void AbilityRecord::SetStartToBackground(const bool flag)
isStartToBackground_ = flag;
}
bool AbilityRecord::IsStartToForeground() const
{
return isStartToForeground_;
}
void AbilityRecord::SetStartToForeground(const bool flag)
{
isStartToForeground_ = flag;
}
bool AbilityRecord::CallRequest()
{
HILOG_INFO("Call Request.");

15
services/abilitymgr/src/mission_info_mgr.cpp
View File

@ -193,14 +193,17 @@ bool MissionInfoMgr::DeleteAllMissionInfos(const std::shared_ptr<MissionListener
return true;
}
static bool DoesNotShowInTheMissionList(int32_t startMethod)
static bool DoesNotShowInTheMissionList(const InnerMissionInfo &mission)
{
switch (static_cast<StartMethod>(startMethod)) {
bool isStartByCall = false;
switch (static_cast<StartMethod>(mission.startMethod)) {
case StartMethod::START_CALL:
return true;
isStartByCall = true;
break;
default:
return false;
isStartByCall = false;
}
return (isStartByCall && !mission.missionInfo.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false));
}
int MissionInfoMgr::GetMissionInfos(int32_t numMax, std::vector<MissionInfo> &missionInfos)
@ -216,7 +219,7 @@ int MissionInfoMgr::GetMissionInfos(int32_t numMax, std::vector<MissionInfo> &mi
break;
}
if (DoesNotShowInTheMissionList(mission.startMethod)) {
if (DoesNotShowInTheMissionList(mission)) {
HILOG_INFO("MissionId[%{public}d] don't show in mission list", mission.missionInfo.id);
continue;
}
@ -246,7 +249,7 @@ int MissionInfoMgr::GetMissionInfoById(int32_t missionId, MissionInfo &missionIn
return -1;
}
if (DoesNotShowInTheMissionList((*it).startMethod)) {
if (DoesNotShowInTheMissionList(*it)) {
HILOG_INFO("MissionId[%{public}d] don't show in mission list", (*it).missionInfo.id);
return -1;
}

28
services/abilitymgr/src/mission_list_manager.cpp
View File

@ -347,9 +347,16 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit
targetRecord->SetWant(abilityRequest.want);
targetRecord->SetIsNewWant(true);
}
/* No need to update condition:
* 1. not start by call
* 2. start by call, but call to background again
* Need to update condition:
* 1. start by call, but this time is not start by call
* 2. start by call, and call to foreground again
*/
if (!(targetMission->IsStartByCall()
&& !CallTypeFilter(startMethod))) {
&& (!CallTypeFilter(startMethod) ||
abilityRequest.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)))) {
HILOG_DEBUG("mission exists. No update required");
return;
}
@ -659,9 +666,13 @@ int MissionListManager::AttachAbilityThread(const sptr<IAbilityScheduler> &sched
abilityRecord->SetScheduler(scheduler);
if (abilityRecord->IsStartedByCall()) {
// started by callability, directly move to background.
if (abilityRecord->GetWant().GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
abilityRecord->SetStartToForeground(true);
DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(token);
} else {
abilityRecord->SetStartToBackground(true);
MoveToBackgroundTask(abilityRecord);
}
return ERR_OK;
}
@ -937,6 +948,13 @@ void MissionListManager::CompleteForegroundSuccess(const std::shared_ptr<Ability
/* PostTask to trigger start Ability from waiting queue */
handler->PostTask(startWaitingAbilityTask, "startWaitingAbility", NEXTABILITY_TIMEOUT);
TerminatePreviousAbility(abilityRecord);
// new version. started by caller, scheduler call request
if (abilityRecord->IsStartedByCall() && abilityRecord->IsStartToForeground() && abilityRecord->IsReady()) {
HILOG_DEBUG("call request after completing foreground state");
abilityRecord->CallRequest();
abilityRecord->SetStartToForeground(false);
}
}
void MissionListManager::TerminatePreviousAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
@ -2357,6 +2375,10 @@ int MissionListManager::CallAbilityLocked(const AbilityRequest &abilityRequest)
auto ret = ResolveAbility(targetAbilityRecord, abilityRequest);
if (ret == ResolveResultType::OK_HAS_REMOTE_OBJ) {
HILOG_DEBUG("target ability has been resolved.");
if (targetAbilityRecord->GetWant().GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
HILOG_DEBUG("target ability needs to be switched to foreground.");
DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(targetAbilityRecord->GetToken());
}
return ERR_OK;
} else if (ret == ResolveResultType::NG_INNER_ERROR) {
HILOG_ERROR("resolve failed, error: %{public}d.", RESOLVE_CALL_ABILITY_INNER_ERR);