!6503 开放IsAbilityControllerStart接口

Merge pull request !6503 from donglin/broker

interfaces/inner_api/ability_manager/include/ability_manager_client.h

@@ -1215,6 +1215,13 @@ public:
      */
     ErrCode DetachAppDebug(const std::string &bundleName);
 
+    /**
+     * @brief Check if ability controller can start.
+     * @param want The want of ability to start.
+     * @return Return true to allow ability to start, or false to reject.
+     */
+    bool IsAbilityControllerStart(const Want &want);
+
 private:
     class AbilityMgrDeathRecipient : public IRemoteObject::DeathRecipient {
     public:

interfaces/inner_api/ability_manager/include/ability_manager_interface.h

@@ -1177,6 +1177,16 @@ public:
      * @return Returns ERR_OK on success, others on failure.
      */
     virtual int32_t DetachAppDebug(const std::string &bundleName) = 0;
+
+    /**
+     * @brief Check if ability controller can start.
+     * @param want The want of ability to start.
+     * @return Return true to allow ability to start, or false to reject.
+     */
+    virtual bool IsAbilityControllerStart(const Want &want)
+    {
+        return true;
+    }
 };
 }  // namespace AAFwk
 }  // namespace OHOS

interfaces/inner_api/ability_manager/include/ability_manager_ipc_interface_code.h

@@ -421,6 +421,7 @@ enum class AbilityManagerInterfaceCode {
     UNREGISTER_COLLABORATOR = 4051,
     MOVE_MISSION_TO_BACKGROUND = 4052,
     TERMINATE_MISSION = 4053,
+    IS_ABILITY_CONTROLLER_START = 4054,
 
     GET_ABILITY_TOKEN = 5001,
 

services/abilitymgr/include/ability_manager_proxy.h

@@ -947,6 +947,13 @@ public:
      */
     int32_t DetachAppDebug(const std::string &bundleName) override;
 
+    /**
+     * @brief Check if ability controller can start.
+     * @param want The want of ability to start.
+     * @return Return true to allow ability to start, or false to reject.
+     */
+    virtual bool IsAbilityControllerStart(const Want &want) override;
+
 private:
     template <typename T>
     int GetParcelableInfos(MessageParcel &reply, std::vector<T> &parcelableInfos);

services/abilitymgr/include/ability_manager_service.h

@@ -1255,6 +1255,13 @@ public:
      */
     int32_t DetachAppDebug(const std::string &bundleName) override;
 
+    /**
+     * @brief Check if ability controller can start.
+     * @param want The want of ability to start.
+     * @return Return true to allow ability to start, or false to reject.
+     */
+    virtual bool IsAbilityControllerStart(const Want &want) override;
+
     // MSG 0 - 20 represents timeout message
     static constexpr uint32_t LOAD_TIMEOUT_MSG = 0;
     static constexpr uint32_t ACTIVE_TIMEOUT_MSG = 1;

services/abilitymgr/include/ability_manager_stub.h

@@ -252,6 +252,8 @@ private:
     int32_t UnregisterAppDebugListenerInner(MessageParcel &data, MessageParcel &reply);
     int32_t AttachAppDebugInner(MessageParcel &data, MessageParcel &reply);
     int32_t DetachAppDebugInner(MessageParcel &data, MessageParcel &reply);
+
+    int32_t IsAbilityControllerStartInner(MessageParcel &data, MessageParcel &reply);
 };
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/src/ability_manager_client.cpp

@@ -1515,5 +1515,16 @@ ErrCode AbilityManagerClient::DetachAppDebug(const std::string &bundleName)
     CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
     return abms->DetachAppDebug(bundleName);
 }
+
+bool AbilityManagerClient::IsAbilityControllerStart(const Want &want)
+{
+    HILOG_DEBUG("call");
+    auto abms = GetAbilityManager();
+    if (abms == nullptr) {
+        HILOG_ERROR("abms is nullptr.");
+        return true;
+    }
+    return abms->IsAbilityControllerStart(want);
+}
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/src/ability_manager_proxy.cpp

@@ -4228,6 +4228,30 @@ int32_t AbilityManagerProxy::DetachAppDebug(const std::string &bundleName)
     return reply.ReadInt32();
 }
 
+bool AbilityManagerProxy::IsAbilityControllerStart(const Want &want)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    if (!WriteInterfaceToken(data)) {
+        HILOG_ERROR("Write interface token failed.");
+        return true;
+    }
+    if (!data.WriteParcelable(&want)) {
+        HILOG_ERROR("WriteWantObject failed.");
+        return true;
+    }
+    
+    auto error = SendRequest(AbilityManagerInterfaceCode::IS_ABILITY_CONTROLLER_START,
+        data, reply, option);
+    if (error != NO_ERROR) {
+        HILOG_ERROR("Send request error: %{public}d", error);
+        return true;
+    }
+    return reply.ReadBool();
+}
+
 ErrCode AbilityManagerProxy::SendRequest(AbilityManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply,
     MessageOption& option)
 {

services/abilitymgr/src/ability_manager_service.cpp

@@ -181,6 +181,7 @@ const int32_t ACCOUNT_MGR_SERVICE_UID = 3058;
 const int32_t BROKER_UID = 5557;
 const int32_t BROKER_RESERVE_UID = 5005;
 const int32_t DMS_UID = 5522;
+const int32_t WMS_UID = 4606;
 const int32_t PREPARE_TERMINATE_TIMEOUT_MULTIPLE = 10;
 const std::string BUNDLE_NAME_KEY = "bundleName";
 const std::string DM_PKG_NAME = "ohos.distributedhardware.devicemanager";
@@ -8410,5 +8411,17 @@ int32_t AbilityManagerService::DetachAppDebug(const std::string &bundleName)
 
     return DelayedSingleton<AppScheduler>::GetInstance()->DetachAppDebug(bundleName);
 }
+
+bool AbilityManagerService::IsAbilityControllerStart(const Want &want)
+{
+    auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
+    auto callingUid = IPCSkeleton::GetCallingUid();
+    if (!isSaCall || (callingUid != BROKER_UID && callingUid != BROKER_RESERVE_UID &&
+        callingUid != WMS_UID)) {
+        HILOG_ERROR("The interface only support for broker and WMS");
+        return true;
+    }
+    return IsAbilityControllerStart(want, want.GetBundle());
+}
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/src/ability_manager_stub.cpp

@@ -156,6 +156,8 @@ void AbilityManagerStub::FirstStepInit()
         &AbilityManagerStub::AttachAppDebugInner;
     requestFuncMap_[static_cast<uint32_t>(AbilityManagerInterfaceCode::DETACH_APP_DEBUG)] =
         &AbilityManagerStub::DetachAppDebugInner;
+    requestFuncMap_[static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_ABILITY_CONTROLLER_START)] =
+        &AbilityManagerStub::IsAbilityControllerStartInner;
 }
 
 void AbilityManagerStub::SecondStepInit()
@@ -2629,5 +2631,17 @@ int32_t AbilityManagerStub::DetachAppDebugInner(MessageParcel &data, MessageParc
     }
     return NO_ERROR;
 }
+
+int32_t AbilityManagerStub::IsAbilityControllerStartInner(MessageParcel &data, MessageParcel &reply)
+{
+    std::unique_ptr<Want> want(data.ReadParcelable<Want>());
+    if (want == nullptr) {
+        HILOG_ERROR("want is nullptr");
+        return true;
+    }
+    bool result = IsAbilityControllerStart(*want);
+    reply.WriteBool(result);
+    return NO_ERROR;
+}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_client_branch_test/ability_manager_client_branch_test.cpp

@@ -1667,5 +1667,17 @@ HWTEST_F(AbilityManagerClientBranchTest, StartSpecifiedAbilityBySCB_0100, TestSi
     Want want;
     client_->StartSpecifiedAbilityBySCB(want);
 }
+
+/**
+ * @tc.name: AbilityManagerClient_IsAbilityControllerStart_0100
+ * @tc.desc: IsAbilityControllerStart
+ * @tc.type: FUNC
+ */
+HWTEST_F(AbilityManagerClientBranchTest, IsAbilityControllerStart_0100, TestSize.Level1)
+{
+    Want want;
+    bool result = client_->IsAbilityControllerStart(want);
+    EXPECT_TRUE(result);
+}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp

@@ -2378,5 +2378,22 @@ HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartSpecifiedAbilityBySCB
     Want want;
     proxy_->StartSpecifiedAbilityBySCB(want);
 }
+
+/*
+ * Feature: AbilityManagerService
+ * Function: IsAbilityControllerStart
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService IsAbilityControllerStart
+ * EnvConditions: NA
+ * CaseDescription: Verify the normal process of IsAbilityControllerStart
+ */
+HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsAbilityControllerStart_001, TestSize.Level1)
+{
+    proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
+    EXPECT_TRUE(proxy_ != nullptr);
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(NO_ERROR));
+    Want want;
+    proxy_->IsAbilityControllerStart(want);
+}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_proxy_test/ability_manager_stub_mock.h

@@ -397,6 +397,7 @@ public:
     MOCK_METHOD1(UnregisterAppDebugListener, int32_t(const sptr<AppExecFwk::IAppDebugListener> &listener));
     MOCK_METHOD1(AttachAppDebug, int32_t(const std::string &bundleName));
     MOCK_METHOD1(DetachAppDebug, int32_t(const std::string &bundleName));
+    MOCK_METHOD1(IsAbilityControllerStart, bool(const Want& want));
 };
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_service_third_test/ability_manager_service_third_test.cpp

@@ -1067,5 +1067,18 @@ HWTEST_F(AbilityManagerServiceThirdTest, RegisterSessionHandler_002, TestSize.Le
     EXPECT_EQ(abilityMs_->RegisterSessionHandler(nullptr), ERR_WRONG_INTERFACE_CALL);
     HILOG_INFO("AbilityManagerServiceThirdTest RegisterSessionHandler_002 end");
 }
+
+/*
+ * Feature: AbilityManagerService
+ * Function: IsAbilityControllerStart
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService IsAbilityControllerStart
+ */
+HWTEST_F(AbilityManagerServiceThirdTest, IsAbilityControllerStart_003, TestSize.Level1)
+{
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    Want want;
+    EXPECT_TRUE(abilityMs_->IsAbilityControllerStart(want));
+}
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_stub_test/ability_manager_stub_impl_mock.h

@@ -397,6 +397,7 @@ public:
     MOCK_METHOD1(UnregisterAppDebugListener, int32_t(const sptr<AppExecFwk::IAppDebugListener> &listener));
     MOCK_METHOD1(AttachAppDebug, int32_t(const std::string &bundleName));
     MOCK_METHOD1(DetachAppDebug, int32_t(const std::string &bundleName));
+    MOCK_METHOD1(IsAbilityControllerStart, bool(const Want& want));
 };
 }  // namespace AAFwk
 }  // namespace OHOS

test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp

@@ -2422,5 +2422,22 @@ HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSpecifiedAbilityBySCBIn
     data.WriteParcelable(&want);
     EXPECT_EQ(stub_->StartSpecifiedAbilityBySCBInner(data, reply), NO_ERROR);
 }
+
+/*
+ * Feature: AbilityManagerService
+ * Function: IsAbilityControllerStartInner
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService IsAbilityControllerStartInner
+ * EnvConditions: NA
+ * CaseDescription: Verify the function IsAbilityControllerStartInner is normal flow.
+ */
+HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsAbilityControllerStartInner_001, TestSize.Level1)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    Want want;
+    data.WriteParcelable(&want);
+    EXPECT_EQ(stub_->IsAbilityControllerStartInner(data, reply), NO_ERROR);
+}
 }  // namespace AAFwk
 }  // namespace OHOS