1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023-2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "player_service_stub_mem.h"
17 #include "player_mem_manage.h"
18 #include "player_server_mem.h"
19 #include "ipc_skeleton.h"
20 #include "media_log.h"
21 #include "media_errors.h"
22 #include "media_dfx.h"
23 #include "media_server_manager.h"
24 #include "mem_mgr_client.h"
25 #include "player_xcollie.h"
26
27 namespace {
28 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "PlayerServiceStubMem"};
29 }
30
31 namespace OHOS {
32 namespace Media {
33 constexpr int32_t PER_INSTANCE_NEED_MEMORY_PERCENT = 10;
34 constexpr int32_t ONE_HUNDRED = 100;
35 constexpr int32_t INSTANCE_NEED_MEMORY_LOW = 102400; // 100M
Create()36 sptr<PlayerServiceStub> PlayerServiceStubMem::Create()
37 {
38 int32_t availableMemory;
39 int32_t totalMemory;
40 int32_t ret = Memory::MemMgrClient::GetInstance().GetAvailableMemory(availableMemory);
41 ret |= Memory::MemMgrClient::GetInstance().GetTotalMemory(totalMemory);
42 MEDIA_LOGD("System available memory:%{public}d, total memory:%{public}d", availableMemory, totalMemory);
43 if (ret == MSERR_OK && availableMemory <= totalMemory / ONE_HUNDRED * PER_INSTANCE_NEED_MEMORY_PERCENT &&
44 availableMemory <= INSTANCE_NEED_MEMORY_LOW) {
45 MEDIA_LOGE("System available memory:%{public}d is less than total memory:%{public}d",
46 availableMemory, totalMemory);
47 return nullptr;
48 }
49
50 sptr<PlayerServiceStubMem> playerStubMem = new(std::nothrow) PlayerServiceStubMem();
51 CHECK_AND_RETURN_RET_LOG(playerStubMem != nullptr, nullptr, "failed to new PlayerServiceStubMem");
52
53 ret = playerStubMem->Init();
54 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "failed to player stubMem init");
55 return playerStubMem;
56 }
57
PlayerServiceStubMem()58 PlayerServiceStubMem::PlayerServiceStubMem()
59 {
60 MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
61 }
62
~PlayerServiceStubMem()63 PlayerServiceStubMem::~PlayerServiceStubMem()
64 {
65 if (playerServer_ != nullptr) {
66 auto task = std::make_shared<TaskHandler<void>>([&, this] {
67 PlayerMemManage::GetInstance().DeregisterPlayerServer(memRecallStruct_);
68 int32_t id = PlayerXCollie::GetInstance().SetTimer("PlayerServiceStubMem::~PlayerServiceStubMem");
69 (void)playerServer_->Release();
70 PlayerXCollie::GetInstance().CancelTimer(id);
71 playerServer_ = nullptr;
72 });
73 (void)taskQue_.EnqueueTask(task);
74 (void)task->GetResult();
75 }
76 }
77
Init()78 int32_t PlayerServiceStubMem::Init()
79 {
80 if (playerServer_ == nullptr) {
81 playerServer_ = PlayerServerMem::Create();
82 appUid_ = IPCSkeleton::GetCallingUid();
83 appPid_ = IPCSkeleton::GetCallingPid();
84 memRecallStruct_ = {
85 std::bind(&PlayerServiceStubMem::ResetFrontGroundForMemManageRecall, this),
86 std::bind(&PlayerServiceStubMem::ResetBackGroundForMemManageRecall, this),
87 std::bind(&PlayerServiceStubMem::ResetMemmgrForMemManageRecall, this),
88 std::bind(&PlayerServiceStubMem::RecoverByMemManageRecall, this),
89 &playerServer_,
90 };
91 MEDIA_LOGI("RegisterPlayerServer uid:%{public}d pid:%{public}d", appUid_, appPid_);
92 PlayerMemManage::GetInstance().RegisterPlayerServer(appUid_, appPid_, memRecallStruct_);
93 }
94 CHECK_AND_RETURN_RET_LOG(playerServer_ != nullptr, MSERR_NO_MEMORY, "failed to create PlayerServer");
95
96 SetPlayerFuncs();
97 return MSERR_OK;
98 }
99
DestroyStub()100 int32_t PlayerServiceStubMem::DestroyStub()
101 {
102 PlayerMemManage::GetInstance().DeregisterPlayerServer(memRecallStruct_);
103 return PlayerServiceStub::DestroyStub();
104 }
105
Release()106 int32_t PlayerServiceStubMem::Release()
107 {
108 PlayerMemManage::GetInstance().DeregisterPlayerServer(memRecallStruct_);
109 return PlayerServiceStub::Release();
110 }
111
ResetFrontGroundForMemManageRecall()112 void PlayerServiceStubMem::ResetFrontGroundForMemManageRecall()
113 {
114 auto task = std::make_shared<TaskHandler<void>>([&, this] {
115 int32_t id = PlayerXCollie::GetInstance().SetTimer("ResetFrontGroundForMemManageRecall");
116 if (playerServer_ != nullptr) {
117 std::static_pointer_cast<PlayerServerMem>(playerServer_)->ResetFrontGroundForMemManage();
118 }
119 PlayerXCollie::GetInstance().CancelTimer(id);
120 return;
121 });
122 (void)taskQue_.EnqueueTask(task);
123 }
124
ResetBackGroundForMemManageRecall()125 void PlayerServiceStubMem::ResetBackGroundForMemManageRecall()
126 {
127 auto task = std::make_shared<TaskHandler<void>>([&, this] {
128 int32_t id = PlayerXCollie::GetInstance().SetTimer("ResetBackGroundForMemManageRecall");
129 if (playerServer_ != nullptr) {
130 std::static_pointer_cast<PlayerServerMem>(playerServer_)->ResetBackGroundForMemManage();
131 }
132 PlayerXCollie::GetInstance().CancelTimer(id);
133 return;
134 });
135 (void)taskQue_.EnqueueTask(task);
136 }
137
ResetMemmgrForMemManageRecall()138 void PlayerServiceStubMem::ResetMemmgrForMemManageRecall()
139 {
140 auto task = std::make_shared<TaskHandler<void>>([&, this] {
141 int32_t id = PlayerXCollie::GetInstance().SetTimer("ResetMemmgrForMemManageRecall");
142 if (playerServer_ != nullptr) {
143 std::static_pointer_cast<PlayerServerMem>(playerServer_)->ResetMemmgrForMemManage();
144 }
145 PlayerXCollie::GetInstance().CancelTimer(id);
146 return;
147 });
148 (void)taskQue_.EnqueueTask(task);
149 }
150
RecoverByMemManageRecall()151 void PlayerServiceStubMem::RecoverByMemManageRecall()
152 {
153 auto task = std::make_shared<TaskHandler<void>>([&, this] {
154 int32_t id = PlayerXCollie::GetInstance().SetTimer("RecoverByMemManage");
155 if (playerServer_ != nullptr) {
156 std::static_pointer_cast<PlayerServerMem>(playerServer_)->RecoverByMemManage();
157 }
158 PlayerXCollie::GetInstance().CancelTimer(id);
159 return;
160 });
161 (void)taskQue_.EnqueueTask(task);
162 }
163 } // namespace Media
164 } // namespace OHOS