mirror of
https://gitee.com/openharmony/ability_ability_runtime
synced 2024-10-07 16:33:53 +00:00
Description: ServiceExtension 支持call调用
Sig:SIG_ApplicaitonFramework Feature or Bugfix:Feature Binary Source:No Signed-off-by: HuangXW <huangxinwei4@huawei.com>
This commit is contained in:
parent
6649e1bbf0
commit
e8f047eb78
@ -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
|
@ -59,20 +59,23 @@ int LocalCallContainer::StartAbilityByCallInner(
|
||||
HILOG_DEBUG("start ability by call, localCallRecord->AddCaller(callback) end");
|
||||
|
||||
auto remote = localCallRecord->GetRemoteObject();
|
||||
if (remote == nullptr) {
|
||||
auto abilityClient = AAFwk::AbilityManagerClient::GetInstance();
|
||||
if (abilityClient == nullptr) {
|
||||
HILOG_ERROR("LocalCallContainer::Resolve abilityClient is nullptr");
|
||||
return ERR_INVALID_VALUE;
|
||||
}
|
||||
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");
|
||||
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");
|
||||
return ERR_INVALID_VALUE;
|
||||
}
|
||||
sptr<IAbilityConnection> connect = iface_cast<IAbilityConnection>(this->AsObject());
|
||||
HILOG_DEBUG("start ability by call, abilityClient->StartAbilityByCall call");
|
||||
return abilityClient->StartAbilityByCall(want, connect, callerToken);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
@ -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" :
|
||||
|
@ -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();
|
||||
|
@ -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",
|
||||
|
@ -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
|
||||
{
|
||||
|
@ -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);
|
||||
|
@ -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
|
||||
|
@ -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;
|
||||
|
||||
|
@ -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.");
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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.
|
||||
abilityRecord->SetStartToBackground(true);
|
||||
MoveToBackgroundTask(abilityRecord);
|
||||
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);
|
||||
|
Loading…
Reference in New Issue
Block a user