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