1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
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 <cmath>
17 #include <media_errors.h>
18 #include <sstream>
19 #include <unordered_map>
20 #include "common/log.h"
21 #include "media_utils.h"
22 #include "iservice_registry.h"
23 #include "bundle_mgr_interface.h"
24 #include "system_ability_definition.h"
25 #include <unordered_set>
26 #include "media_log.h"
27 #include "parameter.h"
28 #include "os_account_manager.h"
29
30 namespace {
31 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_DOMAIN_SYSTEM_PLAYER, "MediaUtils" };
32 }
33
34 namespace OHOS {
35 namespace Media {
36 namespace {
37 const std::pair<Status, int> g_statusPair[] = {
38 {Status::OK, MSERR_OK},
39 {Status::ERROR_UNKNOWN, MSERR_UNKNOWN},
40 {Status::ERROR_AGAIN, MSERR_UNKNOWN},
41 {Status::ERROR_UNIMPLEMENTED, MSERR_UNSUPPORT},
42 {Status::ERROR_INVALID_PARAMETER, MSERR_INVALID_VAL},
43 {Status::ERROR_INVALID_OPERATION, MSERR_INVALID_OPERATION},
44 {Status::ERROR_UNSUPPORTED_FORMAT, MSERR_UNSUPPORT_CONTAINER_TYPE},
45 {Status::ERROR_NOT_EXISTED, MSERR_OPEN_FILE_FAILED},
46 {Status::ERROR_TIMED_OUT, MSERR_UNKNOWN},
47 {Status::ERROR_NO_MEMORY, MSERR_UNKNOWN},
48 {Status::ERROR_INVALID_STATE, MSERR_INVALID_STATE},
49 };
50
51 const std::unordered_map<Status, int32_t> transcoder_statusPair = {
52 {Status::OK, MSERR_OK},
53 {Status::ERROR_UNIMPLEMENTED, MSERR_UNSUPPORT},
54 {Status::ERROR_INVALID_PARAMETER, MSERR_INVALID_VAL},
55 {Status::ERROR_INVALID_OPERATION, MSERR_INVALID_OPERATION},
56 {Status::ERROR_UNSUPPORTED_FORMAT, MSERR_UNSUPPORT_CONTAINER_TYPE},
57 {Status::ERROR_NOT_EXISTED, MSERR_OPEN_FILE_FAILED},
58 {Status::ERROR_NO_MEMORY, MSERR_NO_MEMORY},
59 {Status::ERROR_INVALID_STATE, MSERR_INVALID_STATE},
60 {Status::ERROR_NO_TRACK, MSERR_UNSUPPORT_VID_SRC_TYPE},
61 {Status::ERROR_GET_INPUT_SURFACE_FAILED, MSERR_GET_INPUT_SURFACE_FAILED},
62 {Status::ERROR_SET_OUTPUT_SURFACE_FAILED, MSERR_SET_OUTPUT_SURFACE_FAILED},
63 {Status::ERROR_AUD_ENC_FAILED, MSERR_AUD_ENC_FAILED},
64 {Status::ERROR_VID_RESIZE_FAILED, MSERR_VID_RESIZE_FAILED},
65 };
66
67 const std::array<std::pair<PlaybackRateMode, float>, 12> PLAY_RATE_REFS = {
68 std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_75_X, 0.75),
69 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_00_X, 1.0),
70 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_25_X, 1.25),
71 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_75_X, 1.75),
72 std::make_pair(PlaybackRateMode::SPEED_FORWARD_2_00_X, 2.00),
73 std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_50_X, 0.50),
74 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_50_X, 1.50),
75 std::make_pair(PlaybackRateMode::SPEED_FORWARD_3_00_X, 3.00),
76 std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_25_X, 0.25),
77 std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_125_X, 0.125),
78 std::make_pair(PlaybackRateMode::SPEED_FORWARD_4_00_X, 4.00),
79 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_20_X, 1.20),
80 };
81
82 static int g_readSysParaIdx = 0;
83 std::mutex readSysParaMapMtx_;
84 static std::unordered_map<std::string, std::string> g_readSysParaMap;
85 static int32_t FAULT_API_VERSION = -1;
86 static int32_t ROUND_VERSION_NUMBER = 100;
87 } // namespace
88
GetClientBundleName(int32_t uid)89 std::string __attribute__((visibility("default"))) GetClientBundleName(int32_t uid)
90 {
91 if (uid == 1003) { // 1003 is bootanimation uid
92 return "bootanimation";
93 }
94 std::string bundleName = "";
95 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
96 if (samgr == nullptr) {
97 MEDIA_LOG_E("Get ability manager failed, uid is %{public}d", uid);
98 return bundleName;
99 }
100
101 sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
102 if (object == nullptr) {
103 MEDIA_LOG_E("object is NULL. uid is %{public}d", uid);
104 return bundleName;
105 }
106
107 sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
108 if (bms == nullptr) {
109 MEDIA_LOG_E("bundle manager service is NULL. uid is %{public}d", uid);
110 return bundleName;
111 }
112
113 auto result = bms->GetNameForUid(uid, bundleName);
114 if (result != ERR_OK) {
115 MEDIA_LOG_E("Error GetBundleNameForUid fail, uid is %{public}d", uid);
116 return "";
117 }
118 MEDIA_LOG_I("bundle name is %{public}s uid is %{public}d", bundleName.c_str(), uid);
119
120 return bundleName;
121 }
122
GetApiInfo(int32_t uid,std::string bundleName)123 int32_t __attribute__((visibility("default"))) GetApiInfo(int32_t uid, std::string bundleName)
124 {
125 if (uid == 1003) { // 1003 is bootanimation uid
126 return FAULT_API_VERSION;
127 }
128
129 int32_t userId = 0;
130 AppExecFwk::ApplicationInfo appInfo;
131 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
132 if (samgr == nullptr) {
133 MEDIA_LOG_E("Get ability manager failed");
134 return FAULT_API_VERSION;
135 }
136
137 sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
138 if (object == nullptr) {
139 MEDIA_LOG_E("object is NULL.");
140 return FAULT_API_VERSION;
141 }
142
143 sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
144 if (bms == nullptr) {
145 MEDIA_LOG_E("bundle manager service is NULL.");
146 return FAULT_API_VERSION;
147 }
148
149 if (bundleName == "") {
150 auto result = bms->GetNameForUid(uid, bundleName);
151 if (result != ERR_OK) {
152 MEDIA_LOG_E("Error GetBundleNameForUid fail");
153 return FAULT_API_VERSION;
154 }
155 }
156
157 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(uid, userId);
158 auto flags = static_cast<int32_t>(AppExecFwk::GetApplicationFlag::GET_APPLICATION_INFO_DEFAULT);
159 auto applicationResult = bms->GetApplicationInfo(bundleName, flags, userId, appInfo);
160 if (applicationResult != true) {
161 MEDIA_LOG_E("Error GetApplicationInfo fail");
162 return FAULT_API_VERSION;
163 }
164
165 auto apiVersion = appInfo.apiTargetVersion;
166 auto apiVersionResult = apiVersion % ROUND_VERSION_NUMBER;
167 return apiVersionResult;
168 }
169
GetBundleResourceLabel(std::string bundleName)170 std::string __attribute__((visibility("default"))) GetBundleResourceLabel(std::string bundleName)
171 {
172 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
173 if (samgr == nullptr) {
174 MEDIA_LOG_E("Get ability manager failed");
175 return bundleName;
176 }
177
178 sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
179 if (object == nullptr) {
180 MEDIA_LOG_E("object is NULL.");
181 return bundleName;
182 }
183
184 sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
185 if (bms == nullptr) {
186 MEDIA_LOG_E("bundle manager service is NULL.");
187 return bundleName;
188 }
189
190 auto bundleResourceProxy = bms->GetBundleResourceProxy();
191 if (bundleResourceProxy == nullptr) {
192 MEDIA_LOG_E("GetBundleResourceProxy fail");
193 return bundleName;
194 }
195 AppExecFwk::BundleResourceInfo resourceInfo;
196 auto result = bundleResourceProxy->GetBundleResourceInfo(bundleName,
197 static_cast<uint32_t>(OHOS::AppExecFwk::ResourceFlag::GET_RESOURCE_INFO_ALL), resourceInfo);
198 if (result != ERR_OK) {
199 MEDIA_LOG_E("GetBundleResourceInfo failed");
200 return bundleName;
201 }
202 MEDIA_LOG_I("bundle resource label is %{public}s ", (resourceInfo.label).c_str());
203 return resourceInfo.label;
204 }
205
206
TransStatus(Status status)207 int __attribute__((visibility("default"))) TransStatus(Status status)
208 {
209 for (const auto& errPair : g_statusPair) {
210 if (errPair.first == status) {
211 return errPair.second;
212 }
213 }
214 return MSERR_UNKNOWN;
215 }
216
TransTranscoderStatus(Status status)217 int32_t __attribute__((visibility("default"))) TransTranscoderStatus(Status status)
218 {
219 auto errCodeIter = transcoder_statusPair.find(status);
220 if (errCodeIter != transcoder_statusPair.end()) {
221 return errCodeIter->second;
222 }
223 return MSERR_UNKNOWN;
224 }
225
TransStateId2PlayerState(PlayerStateId state)226 PlayerStates __attribute__((visibility("default"))) TransStateId2PlayerState(PlayerStateId state)
227 {
228 PlayerStates playerState = PLAYER_STATE_ERROR;
229 switch (state) {
230 case PlayerStateId::IDLE:
231 playerState = PLAYER_IDLE;
232 break;
233 case PlayerStateId::INIT:
234 playerState = PLAYER_INITIALIZED;
235 break;
236 case PlayerStateId::PREPARING:
237 playerState = PLAYER_PREPARING;
238 break;
239 case PlayerStateId::READY:
240 playerState = PLAYER_PREPARED;
241 break;
242 case PlayerStateId::PAUSE:
243 playerState = PLAYER_PAUSED;
244 break;
245 case PlayerStateId::PLAYING:
246 playerState = PLAYER_STARTED;
247 break;
248 case PlayerStateId::STOPPED:
249 playerState = PLAYER_STOPPED;
250 break;
251 case PlayerStateId::EOS:
252 playerState = PLAYER_PLAYBACK_COMPLETE;
253 break;
254 default:
255 break;
256 }
257 return playerState;
258 }
259
Transform2SeekMode(PlayerSeekMode mode)260 Plugins::SeekMode __attribute__((visibility("default"))) Transform2SeekMode(PlayerSeekMode mode)
261 {
262 switch (mode) {
263 case PlayerSeekMode::SEEK_NEXT_SYNC:
264 return Plugins::SeekMode::SEEK_NEXT_SYNC;
265 case PlayerSeekMode::SEEK_PREVIOUS_SYNC:
266 return Plugins::SeekMode::SEEK_PREVIOUS_SYNC;
267 case PlayerSeekMode::SEEK_CLOSEST_SYNC:
268 return Plugins::SeekMode::SEEK_CLOSEST_SYNC;
269 case PlayerSeekMode::SEEK_CLOSEST:
270 default:
271 return Plugins::SeekMode::SEEK_CLOSEST;
272 }
273 }
StringnessPlayerState(PlayerStates state)274 const std::string& __attribute__((visibility("default"))) StringnessPlayerState(PlayerStates state)
275 {
276 using StateString = std::pair<PlayerStates, std::string>;
277 const static std::array<StateString, 9> maps = { // array size
278 std::make_pair(PlayerStates::PLAYER_STATE_ERROR, "state error"),
279 std::make_pair(PlayerStates::PLAYER_IDLE, "idle"),
280 std::make_pair(PlayerStates::PLAYER_INITIALIZED, "init"),
281 std::make_pair(PlayerStates::PLAYER_PREPARING, "preparing"),
282 std::make_pair(PlayerStates::PLAYER_PREPARED, "prepared"),
283 std::make_pair(PlayerStates::PLAYER_STARTED, "started"),
284 std::make_pair(PlayerStates::PLAYER_PAUSED, "paused"),
285 std::make_pair(PlayerStates::PLAYER_STOPPED, "stopped"),
286 std::make_pair(PlayerStates::PLAYER_PLAYBACK_COMPLETE, "completed"),
287 };
288 const static std::string UNKNOWN = "unknown";
289 auto ite = std::find_if(maps.begin(), maps.end(), [&] (const StateString& item) -> bool {
290 return item.first == state;
291 });
292 if (ite == maps.end()) {
293 return UNKNOWN;
294 }
295 return ite->second;
296 }
TransformPlayRate2Float(PlaybackRateMode rateMode)297 float __attribute__((visibility("default"))) TransformPlayRate2Float(PlaybackRateMode rateMode)
298 {
299 auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
300 return pair.first == rateMode;
301 });
302 if (ite == PLAY_RATE_REFS.end()) {
303 return 1.0f;
304 }
305 return ite->second;
306 }
TransformFloat2PlayRate(float rate)307 PlaybackRateMode __attribute__((visibility("default"))) TransformFloat2PlayRate(float rate)
308 {
309 auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
310 return std::fabs(rate - pair.second) < 1e-3;
311 });
312 if (ite == PLAY_RATE_REFS.end()) {
313 return PlaybackRateMode::SPEED_FORWARD_1_00_X;
314 }
315 return ite->first;
316 }
317
IsEnableOptimizeDecode()318 bool __attribute__((visibility("default"))) IsEnableOptimizeDecode()
319 {
320 char useOptimizeDecode[10] = {0}; // 10: system param usage
321 auto res = GetParameter("debug.media_service.optimize_decode", "1", useOptimizeDecode, sizeof(useOptimizeDecode));
322 return res == 1 && useOptimizeDecode[0] == '1';
323 }
324
IsAppEnableRenderFirstFrame(int32_t uid)325 bool __attribute__((visibility("default"))) IsAppEnableRenderFirstFrame(int32_t uid)
326 {
327 return uid != 1003; // 1003 is bootanimation uid
328 }
329
GetPackageName(const char * key,std::string & value)330 bool __attribute__((visibility("default"))) GetPackageName(const char *key, std::string &value)
331 {
332 CHECK_AND_RETURN_RET_LOG(key != nullptr, false, "key is nullptr");
333 value = "";
334 char paraValue[100] = {0}; // 100 for system parameter
335 auto res = GetParameter(key, "-1", paraValue, sizeof(paraValue));
336 CHECK_AND_RETURN_RET_LOG(res >= 0, false, "GetSysPara fail, key:%{public}s res:%{public}d", key, res);
337 std::stringstream valueStr;
338 valueStr << paraValue;
339 valueStr >> value;
340 MEDIA_LOG_I("Config parameter %{public}s : %{public}s", key, value.c_str());
341 return true;
342 }
343
GetScreenCaptureSystemParam()344 std::unordered_map<std::string, std::string>& __attribute__((visibility("default"))) GetScreenCaptureSystemParam()
345 {
346 std::lock_guard<std::mutex> lock(readSysParaMapMtx_);
347 if (g_readSysParaIdx == 0) {
348 GetPackageName("const.multimedia.screencapture.dialogconnectionbundlename",
349 g_readSysParaMap["const.multimedia.screencapture.dialogconnectionbundlename"]);
350 GetPackageName("const.multimedia.screencapture.dialogconnectionabilityname",
351 g_readSysParaMap["const.multimedia.screencapture.dialogconnectionabilityname"]);
352 GetPackageName("const.multimedia.screencapture.screenrecorderbundlename",
353 g_readSysParaMap["const.multimedia.screencapture.screenrecorderbundlename"]);
354 GetPackageName("const.multimedia.screencapture.screenrecorderabilityname",
355 g_readSysParaMap["const.multimedia.screencapture.screenrecorderabilityname"]);
356 GetPackageName("const.multimedia.screencapture.hiviewcarebundlename",
357 g_readSysParaMap["const.multimedia.screencapture.hiviewcarebundlename"]);
358 g_readSysParaIdx++;
359 }
360 return g_readSysParaMap;
361 }
362
GetAPIVersion()363 int32_t __attribute__((visibility("default"))) GetAPIVersion()
364 {
365 #if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
366 uint32_t targetVersion = 0;
367 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
368 if (samgr == nullptr) {
369 MEDIA_LOG_E("Get ability manager failed");
370 return FAULT_API_VERSION;
371 }
372 sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
373 if (object == nullptr) {
374 MEDIA_LOG_E("Object is NULL");
375 return FAULT_API_VERSION;
376 }
377
378 sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
379 if (bms == nullptr) {
380 MEDIA_LOG_E("Bundle manager service is NULL.");
381 return FAULT_API_VERSION;
382 }
383 AppExecFwk::BundleInfo bundleInfo;
384 if (bms->GetBundleInfoForSelf(0, bundleInfo) != ERR_OK) {
385 MEDIA_LOG_E("Get bundle info for self failed");
386 return FAULT_API_VERSION;
387 }
388 targetVersion = bundleInfo.targetVersion;
389 int32_t apiVersionResult = static_cast<int32_t>(targetVersion % 100);
390 return apiVersionResult;
391 #else
392 return FAULT_API_VERSION;
393 #endif
394 }
395
396 } // namespace Media
397 } // namespace OHOS
398