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