openharmony/ability_ability_runtime
1
0
Fork 0
mirror of https://github.com/openharmony/ability_ability_runtime.git synced 2026-08-24 22:21:36 -04:00
Code Issues Packages Projects Releases Wiki Activity

!7877 补充Service打点

Browse Source 
Merge pull request !7877 from 周士成/hisysevent
This commit is contained in:
openharmony_ci
2024-03-29 04:47:19 +00:00
committed by Gitee
parent c7db6da791 50be60aff0
commit 8dbab6798d
11 changed files with 607 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hisysevent.yaml
+25
View File
@@ -182,6 +182,11 @@ START_SERVICE:
MODULE_NAME: {type: STRING, desc: module name}
ABILITY_NAME: {type: STRING, desc: ability name}
EXTENSION_TYPE: {type: INT32, desc: extension type}
TIME: {type: INT64, desc: start service time}
PID: {type: INT32, desc: processId}
PROCESS_NAME: {type: STRING, desc: process name}
CALLER_PROCESS_ID: {type: INT32, desc: caller processId}
CALLER_PROCESS_NAME: {type: STRING, desc: caller process name}
STOP_SERVICE:
__BASE: {type: BEHAVIOR, level: MINOR, tag: ability, desc: stop serviceExtensionAbility}
@@ -190,6 +195,11 @@ STOP_SERVICE:
MODULE_NAME: {type: STRING, desc: module name}
ABILITY_NAME: {type: STRING, desc: ability name}
EXTENSION_TYPE: {type: INT32, desc: extension type}
TIME: {type: INT64, desc: stop service time}
PID: {type: INT32, desc: processId}
PROCESS_NAME: {type: STRING, desc: process name}
CALLER_PROCESS_ID: {type: INT32, desc: caller processId}
CALLER_PROCESS_NAME: {type: STRING, desc: caller process name}
CONNECT_SERVICE:
__BASE: {type: BEHAVIOR, level: MINOR, tag: ability, desc: connect serviceAbility}
@@ -197,9 +207,19 @@ CONNECT_SERVICE:
BUNDLE_NAME: {type: STRING, desc: bundle name}
MODULE_NAME: {type: STRING, desc: module name}
ABILITY_NAME: {type: STRING, desc: ability name}
TIME: {type: INT64, desc: connect service time}
PID: {type: INT32, desc: processId}
PROCESS_NAME: {type: STRING, desc: process name}
CALLER_PROCESS_ID: {type: INT32, desc: caller processId}
CALLER_PROCESS_NAME: {type: STRING, desc: caller process name}
DISCONNECT_SERVICE:
__BASE: {type: BEHAVIOR, level: MINOR, tag: ability, desc: disconnect serviceAbility}
TIME: {type: INT64, desc: disconnect service time}
PID: {type: INT32, desc: processId}
PROCESS_NAME: {type: STRING, desc: process name}
CALLER_PROCESS_ID: {type: INT32, desc: caller processId}
CALLER_PROCESS_NAME: {type: STRING, desc: caller process name}
# app behavior event
@@ -279,13 +299,18 @@ PROCESS_START:
CALLER_BUNDLE_NAME: {type: STRING, desc: caller bundle name}
CALLER_UID: {type: INT32, desc: caller uid}
CALLER_PROCESS_NAME: {type: STRING, desc: caller process name}
CALLER_PROCESS_ID: {type: INT32, desc: caller processId}
BUNDLE_NAME: {type: STRING, desc: bundle name}
PROCESS_NAME: {type: STRING, desc: process name}
PID: {type: INT32, desc: processId}
PROCESS_EXIT:
__BASE: {type: BEHAVIOR, level: MINOR, tag: app, desc: application process exit event reporting}
EXIT_TIME: {type: INT64, desc: process exit time}
EXIT_RESULT: {type: INT32, desc: process exit result}
EXIT_PID: {type: INT32, desc: pid}
PROCESS_NAME: {type: STRING, desc: process name}
EXTENSION_TYPE: {type: INT32, desc: process exit extension type}
DRAWN_COMPLETED:
__BASE: {type: BEHAVIOR, level: MINOR, tag: app, desc: drawn completed event reporting}
services/abilitymgr/include/ability_connect_manager.h
+2
View File
@@ -27,6 +27,7 @@
#include "event_handler_wrap.h"
#include "ability_record.h"
#include "ability_running_info.h"
#include "event_report.h"
#include "extension_config.h"
#include "extension_running_info.h"
#include "connection_record.h"
@@ -529,6 +530,7 @@ private:
const AbilityRequest &abilityRequest, const sptr<UIExtensionAbilityConnectInfo> &connectInfo,
std::shared_ptr<AbilityRecord> &targetService, bool &isLoadedAbility);
void HandleNotifyAssertFaultDialogDied(const std::shared_ptr<AbilityRecord> &abilityRecord);
EventInfo BuildEventInfo(const std::shared_ptr<AbilityRecord> &abilityRecord);
private:
const std::string TASK_ON_CALLBACK_DIED = "OnCallbackDiedTask";
services/abilitymgr/src/ability_connect_manager.cpp
+42
View File
@@ -398,6 +398,8 @@ int AbilityConnectManager::StopServiceAbilityLocked(const AbilityRequest &abilit
}
TerminateRecord(abilityRecord);
EventInfo eventInfo = BuildEventInfo(abilityRecord);
EventReport::SendStopServiceEvent(EventName::STOP_SERVICE, eventInfo);
return ERR_OK;
}
@@ -642,6 +644,9 @@ int AbilityConnectManager::DisconnectAbilityLocked(const sptr<IAbilityConnection
if (result != ERR_OK) {
TAG_LOGE(AAFwkTag::ABILITYMGR, "Disconnect ability fail , ret = %{public}d.", result);
break;
} else {
EventInfo eventInfo = BuildEventInfo(abilityRecord);
EventReport::SendDisconnectServiceEvent(EventName::DISCONNECT_SERVICE, eventInfo);
}
}
}
@@ -878,6 +883,12 @@ int AbilityConnectManager::ScheduleConnectAbilityDoneLocked(
DelayedSingleton<AppScheduler>::GetInstance()->UpdateExtensionState(
token, AppExecFwk::ExtensionState::EXTENSION_STATE_CONNECTED);
}
EventInfo eventInfo = BuildEventInfo(abilityRecord);
eventInfo.userId = userId_;
eventInfo.bundleName = abilityRecord->GetAbilityInfo().bundleName;
eventInfo.moduleName = abilityRecord->GetAbilityInfo().moduleName;
eventInfo.abilityName = abilityRecord->GetAbilityInfo().name;
EventReport::SendConnectServiceEvent(EventName::CONNECT_SERVICE, eventInfo);
abilityRecord->SetConnRemoteObject(remoteObject);
// There may be multiple callers waiting for the connection result
@@ -963,6 +974,8 @@ int AbilityConnectManager::ScheduleCommandAbilityDoneLocked(const sptr<IRemoteOb
abilityRecord->GetAbilityState());
return INVALID_CONNECTION_STATE;
}
EventInfo eventInfo = BuildEventInfo(abilityRecord);
EventReport::SendStartServiceEvent(EventName::START_SERVICE, eventInfo);
// complete command and pop waiting start ability from queue.
CompleteCommandAbility(abilityRecord);
@@ -2707,5 +2720,34 @@ void AbilityConnectManager::SignRestartAppFlag(const std::string &bundleName)
abilityRecord->SetRestartAppFlag(true);
}
}
EventInfo AbilityConnectManager::BuildEventInfo(const std::shared_ptr<AbilityRecord> &abilityRecord)
{
EventInfo eventInfo;
if (abilityRecord == nullptr) {
HILOG_ERROR("build eventInfo failed, abilityRecord is nullptr");
return eventInfo;
}
AppExecFwk::RunningProcessInfo processInfo;
DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByToken(abilityRecord->GetToken(), processInfo);
eventInfo.pid = processInfo.pid_;
eventInfo.processName = processInfo.processName_;
eventInfo.time = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
auto callerPid = abilityRecord->GetWant().GetIntParam(Want::PARAM_RESV_CALLER_PID, -1);
eventInfo.callerPid = callerPid == -1 ? IPCSkeleton::GetCallingPid() : callerPid;
DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByPid(eventInfo.callerPid, processInfo);
eventInfo.callerPid = processInfo.pid_;
eventInfo.callerProcessName = processInfo.processName_;
if (!abilityRecord->IsCreateByConnect()) {
auto abilityInfo = abilityRecord->GetAbilityInfo();
eventInfo.extensionType = static_cast<int32_t>(abilityInfo.extensionAbilityType);
eventInfo.userId = userId_;
eventInfo.bundleName = abilityInfo.bundleName;
eventInfo.moduleName = abilityInfo.moduleName;
eventInfo.abilityName = abilityInfo.name;
}
return eventInfo;
}
} // namespace AAFwk
} // namespace OHOS
services/abilitymgr/src/ability_manager_service.cpp
-8
View File
@@ -2307,7 +2307,6 @@ int AbilityManagerService::StartExtensionAbilityInner(const Want &want, const sp
}
EventInfo eventInfo = BuildEventInfo(want, userId);
eventInfo.extensionType = static_cast<int32_t>(extensionType);
EventReport::SendExtensionEvent(EventName::START_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
auto result = CheckDlpForExtension(want, callerToken, userId, eventInfo, EventName::START_EXTENSION_ERROR);
if (result != ERR_OK) {
@@ -2511,7 +2510,6 @@ int AbilityManagerService::StartUIExtensionAbility(const sptr<SessionInfo> &exte
AppExecFwk::ExtensionAbilityType::UI : AppExecFwk::ConvertToExtensionAbilityType(extensionTypeStr);
EventInfo eventInfo = BuildEventInfo(extensionSessionInfo->want, userId);
eventInfo.extensionType = static_cast<int32_t>(extensionType);
EventReport::SendExtensionEvent(EventName::START_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
if (InsightIntentExecuteParam::IsInsightIntentExecute(extensionSessionInfo->want)) {
int32_t result = DelayedSingleton<InsightIntentExecuteManager>::GetInstance()->CheckAndUpdateWant(
@@ -2653,7 +2651,6 @@ int AbilityManagerService::StopExtensionAbility(const Want &want, const sptr<IRe
}
EventInfo eventInfo = BuildEventInfo(want, userId);
eventInfo.extensionType = static_cast<int32_t>(extensionType);
EventReport::SendExtensionEvent(EventName::STOP_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
auto result = CheckDlpForExtension(want, callerToken, userId, eventInfo, EventName::STOP_EXTENSION_ERROR);
if (result != ERR_OK) {
@@ -2759,7 +2756,6 @@ void AbilityManagerService::StopSwitchUserDialogInner(const Want &want, const in
TAG_LOGD(AAFwkTag::ABILITYMGR, "Stop switch user dialog inner come");
EventInfo eventInfo = BuildEventInfo(want, lastUserId);
eventInfo.extensionType = static_cast<int32_t>(AppExecFwk::ExtensionAbilityType::SERVICE);
EventReport::SendExtensionEvent(EventName::STOP_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
AbilityRequest abilityRequest;
auto result =
GenerateExtensionAbilityRequest(want, abilityRequest, nullptr, lastUserId);
@@ -3253,7 +3249,6 @@ int AbilityManagerService::ConnectAbilityCommon(
CHECK_CALLER_IS_SYSTEM_APP;
}
EventInfo eventInfo = BuildEventInfo(want, userId);
EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
auto result = CheckDlpForExtension(want, callerToken, userId, eventInfo, EventName::CONNECT_SERVICE_ERROR);
if (result != ERR_OK) {
@@ -3357,7 +3352,6 @@ int AbilityManagerService::ConnectUIExtensionAbility(const Want &want, const spt
}
EventInfo eventInfo = BuildEventInfo(want, userId);
EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
sptr<IRemoteObject> callerToken = sessionInfo->callerToken;
if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
@@ -3445,7 +3439,6 @@ int AbilityManagerService::DisconnectAbility(sptr<IAbilityConnection> connect)
HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
TAG_LOGD(AAFwkTag::ABILITYMGR, "Disconnect ability begin.");
EventInfo eventInfo;
EventReport::SendExtensionEvent(EventName::DISCONNECT_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
@@ -6958,7 +6951,6 @@ void AbilityManagerService::StartSwitchUserDialogInner(const Want &want, int32_t
TAG_LOGD(AAFwkTag::ABILITYMGR, "Start switch user dialog inner come");
EventInfo eventInfo = BuildEventInfo(want, lastUserId);
eventInfo.extensionType = static_cast<int32_t>(AppExecFwk::ExtensionAbilityType::SERVICE);
EventReport::SendExtensionEvent(EventName::START_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
AbilityRequest abilityRequest;
auto result = GenerateExtensionAbilityRequest(want, abilityRequest, nullptr, lastUserId);
if (result != ERR_OK) {
services/appmgr/include/app_mgr_service_inner.h
+2 -2
View File
@@ -1233,9 +1233,9 @@ private:
void SendAppStartupTypeEvent(const std::shared_ptr<AppRunningRecord> &appRecord,
const std::shared_ptr<AbilityInfo> &abilityInfo, const AppStartType startType);
void SendProcessExitEvent(pid_t pid);
void SendProcessExitEvent(const std::shared_ptr<AppRunningRecord> &appRecord);
void SendProcessExitEventTask(pid_t pid, time_t exitTime, int32_t count);
void SendProcessExitEventTask(const std::shared_ptr<AppRunningRecord> &appRecord, time_t exitTime, int32_t count);
void UpDateStartupType(const std::shared_ptr<AbilityInfo> &info, int32_t &abilityType, int32_t &extensionType);
services/appmgr/src/app_mgr_service_inner.cpp
+38 -28
View File
@@ -713,7 +713,7 @@ void AppMgrServiceInner::ApplicationForegrounded(const int32_t recordId)
} else {
TAG_LOGE(AAFwkTag::APPMGR, "callerRecord is nullptr, can not get callerBundleName.");
}
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::APP_FOREGROUND, HiSysEventType::BEHAVIOR, eventInfo);
AAFwk::EventReport::SendAppForegroundEvent(AAFwk::EventName::APP_FOREGROUND, eventInfo);
}
void AppMgrServiceInner::ApplicationBackgrounded(const int32_t recordId)
@@ -754,7 +754,7 @@ void AppMgrServiceInner::ApplicationBackgrounded(const int32_t recordId)
eventInfo.pid = appRecord->GetPriorityObject()->GetPid();
eventInfo.processName = appRecord->GetProcessName();
eventInfo.processType = static_cast<int32_t>(appRecord->GetProcessType());
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::APP_BACKGROUND, HiSysEventType::BEHAVIOR, eventInfo);
AAFwk::EventReport::SendAppBackgroundEvent(AAFwk::EventName::APP_BACKGROUND, eventInfo);
}
void AppMgrServiceInner::ApplicationTerminated(const int32_t recordId)
@@ -917,47 +917,56 @@ int32_t AppMgrServiceInner::KillApplicationByUid(const std::string &bundleName,
return result;
}
void AppMgrServiceInner::SendProcessExitEventTask(pid_t pid, time_t exitTime, int32_t count)
void AppMgrServiceInner::SendProcessExitEventTask(
const std::shared_ptr<AppRunningRecord> &appRecord, time_t exitTime, int32_t count)
{
if (appRecord == nullptr) {
HILOG_ERROR("appRecord is nullptr");
return;
}
if (appRecord->GetPriorityObject() == nullptr) {
HILOG_ERROR("Get priority object is nullptr.");
return;
}
auto pid = appRecord->GetPriorityObject()->GetPid();
auto exitResult = !ProcessExist(pid);
constexpr int32_t EXIT_SUCESS = 0;
constexpr int32_t EXIT_FAILED = -1;
AAFwk::EventInfo eventInfo;
eventInfo.time = exitTime;
eventInfo.pid = pid;
eventInfo.processName = appRecord->GetProcessName();
eventInfo.extensionType = static_cast<int32_t>(appRecord->GetExtensionType());
if (exitResult) {
AAFwk::EventInfo eventInfo;
eventInfo.time = exitTime;
eventInfo.exitResult = EXIT_SUCESS;
eventInfo.pid = pid;
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::PROCESS_EXIT, HiSysEventType::BEHAVIOR, eventInfo);
AAFwk::EventReport::SendProcessExitEvent(AAFwk::EventName::PROCESS_EXIT, eventInfo);
TAG_LOGI(AAFwkTag::APPMGR, "time : %{public}" PRId64 ", exitResult : %{public}d, pid : %{public}d",
eventInfo.time, eventInfo.exitResult, eventInfo.pid);
return;
}
if (--count <= 0) {
AAFwk::EventInfo eventInfo;
eventInfo.time = exitTime;
eventInfo.exitResult = EXIT_FAILED;
eventInfo.pid = pid;
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::PROCESS_EXIT, HiSysEventType::BEHAVIOR, eventInfo);
AAFwk::EventReport::SendProcessExitEvent(AAFwk::EventName::PROCESS_EXIT, eventInfo);
TAG_LOGI(AAFwkTag::APPMGR, "time : %{public}" PRId64 ", exitResult : %{public}d, pid : %{public}d",
eventInfo.time, eventInfo.exitResult, eventInfo.pid);
return;
}
auto sendEventTask = [inner = shared_from_this(), pid, exitTime, count] () {
inner->SendProcessExitEventTask(pid, exitTime, count);
auto sendEventTask = [inner = shared_from_this(), appRecord, exitTime, count] () {
inner->SendProcessExitEventTask(appRecord, exitTime, count);
};
taskHandler_->SubmitTask(sendEventTask, PROCESS_EXIT_EVENT_TASK, KILL_PROCESS_DELAYTIME_MICRO_SECONDS);
}
void AppMgrServiceInner::SendProcessExitEvent(pid_t pid)
void AppMgrServiceInner::SendProcessExitEvent(const std::shared_ptr<AppRunningRecord> &appRecord)
{
TAG_LOGD(AAFwkTag::APPMGR, "called.");
time_t currentTime;
time(&currentTime);
constexpr int32_t RETRY_COUNT = 5;
SendProcessExitEventTask(pid, currentTime, RETRY_COUNT);
SendProcessExitEventTask(appRecord, currentTime, RETRY_COUNT);
return;
}
@@ -2390,7 +2399,8 @@ bool AppMgrServiceInner::SendProcessStartEvent(const std::shared_ptr<AppRunningR
TAG_LOGI(AAFwkTag::APPMGR, "Abilities nullptr!");
}
auto callerAppRecord = GetAppRunningRecordByPid(appRecord->GetCallerPid());
eventInfo.callerPid = appRecord->GetCallerPid() == -1 ? IPCSkeleton::GetCallingPid() : appRecord->GetCallerPid();
auto callerAppRecord = GetAppRunningRecordByPid(eventInfo.callerPid);
if (callerAppRecord == nullptr) {
Security::AccessToken::NativeTokenInfo nativeTokenInfo = {};
auto token = appRecord->GetCallerTokenId() == -1 ?
@@ -2409,7 +2419,13 @@ bool AppMgrServiceInner::SendProcessStartEvent(const std::shared_ptr<AppRunningR
if (!appRecord->GetBundleName().empty()) {
eventInfo.bundleName = appRecord->GetBundleName();
}
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::PROCESS_START, HiSysEventType::BEHAVIOR, eventInfo);
eventInfo.processName = appRecord->GetProcessName();
if (appRecord->GetPriorityObject() == nullptr) {
HILOG_ERROR("appRecord's priorityObject is null");
} else {
eventInfo.pid = appRecord->GetPriorityObject()->GetPid();
}
AAFwk::EventReport::SendProcessStartEvent(AAFwk::EventName::PROCESS_START, eventInfo);
TAG_LOGD(AAFwkTag::APPMGR, "%{public}s. time : %{public}" PRId64 ", abilityType : %{public}d, bundle : %{public}s,\
uid : %{public}d, process : %{public}s",
__func__, eventInfo.time, eventInfo.abilityType, eventInfo.callerBundleName.c_str(), eventInfo.callerUid,
@@ -2560,9 +2576,7 @@ void AppMgrServiceInner::ClearAppRunningData(const std::shared_ptr<AppRunningRec
KillChildProcess(appRecord);
KillAttachedChildProcess(appRecord);
if (appRecord->GetPriorityObject() != nullptr) {
SendProcessExitEvent(appRecord->GetPriorityObject()->GetPid());
}
SendProcessExitEvent(appRecord);
if (!appRunningManager_->CheckAppRunningRecordIsExistByBundleName(appRecord->GetBundleName())) {
OnAppStopped(appRecord);
@@ -2688,10 +2702,10 @@ void AppMgrServiceInner::TerminateApplication(const std::shared_ptr<AppRunningRe
OnAppStateChanged(appRecord, ApplicationState::APP_STATE_TERMINATED, false, false);
pid_t pid = appRecord->GetPriorityObject()->GetPid();
if (pid > 0) {
auto timeoutTask = [pid, innerService = shared_from_this()]() {
auto timeoutTask = [appRecord, pid, innerService = shared_from_this()]() {
TAG_LOGI(AAFwkTag::APPMGR, "KillProcessByPid %{public}d", pid);
int32_t result = innerService->KillProcessByPid(pid, "TerminateApplication");
innerService->SendProcessExitEvent(pid);
innerService->SendProcessExitEvent(appRecord);
if (result < 0) {
TAG_LOGE(AAFwkTag::APPMGR, "KillProcessByPid kill process is fail");
return;
@@ -5197,11 +5211,7 @@ void AppMgrServiceInner::ApplicationTerminatedSendProcessEvent(const std::shared
appDebugManager_->RemoveAppDebugInfo(info);
TAG_LOGD(AAFwkTag::APPMGR, "Application is terminated.");
if (appRecord->GetPriorityObject() == nullptr) {
TAG_LOGE(AAFwkTag::APPMGR, "Get priority object is nullptr.");
return;
}
SendProcessExitEvent(appRecord->GetPriorityObject()->GetPid());
SendProcessExitEvent(appRecord);
}
void AppMgrServiceInner::ClearAppRunningDataForKeepAlive(const std::shared_ptr<AppRunningRecord> &appRecord)
@@ -5633,7 +5643,7 @@ void AppMgrServiceInner::SendAppLaunchEvent(const std::shared_ptr<AppRunningReco
eventInfo.callerVersionCode = callerApplicationInfo->versionCode;
}
}
AAFwk::EventReport::SendAppEvent(AAFwk::EventName::APP_LAUNCH, HiSysEventType::BEHAVIOR, eventInfo);
AAFwk::EventReport::SendAppLaunchEvent(AAFwk::EventName::APP_LAUNCH, eventInfo);
}
bool AppMgrServiceInner::IsFinalAppProcessByBundleName(const std::string &bundleName)
services/common/include/event_report.h
+11
View File
@@ -50,6 +50,8 @@ struct EventInfo {
std::string callerVersionName;
std::string uri;
int32_t processType = -1;
int32_t callerPid = -1;
int64_t duration = 0;
};
enum class EventName {
@@ -102,6 +104,15 @@ public:
static void SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo);
static void SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo);
static void SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo);
static void SendAppLaunchEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendAppForegroundEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendAppBackgroundEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendProcessStartEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendProcessExitEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendStartServiceEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendStopServiceEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendConnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo);
static void SendDisconnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo);
private:
static std::string ConvertEventName(const EventName &eventName);
services/common/src/event_report.cpp
+216 -109
View File
@@ -39,6 +39,7 @@ constexpr const char *EVENT_KEY_STARTUP_EXTENSION_TYPE = "STARTUP_EXTENSION_TYPE
constexpr const char *EVENT_KEY_CALLER_BUNDLE_NAME = "CALLER_BUNDLE_NAME";
constexpr const char *EVENT_KEY_CALLER_UID = "CALLER_UID";
constexpr const char *EVENT_KEY_CALLER_PROCESS_NAME = "CALLER_PROCESS_NAME";
constexpr const char *EVENT_KEY_CALLER_PROCESS_ID = "CALLER_PROCESS_ID";
constexpr const char *EVENT_KEY_EXIT_TIME = "EXIT_TIME";
constexpr const char *EVENT_KEY_EXIT_RESULT = "EXIT_RESULT";
constexpr const char *EVENT_KEY_EXIT_PID = "EXIT_PID";
@@ -51,6 +52,9 @@ constexpr const char *EVENT_KEY_URI = "URI";
constexpr const char *EVENT_KEY_RESTART_TIME = "RESTART_TIME";
constexpr const char *EVENT_KEY_APP_UID = "APP_UID";
constexpr const char *EVENT_KEY_PROCESS_TYPE = "PROCESS_TYPE";
constexpr const char *EVENT_KEY_TIME = "TIME";
constexpr const char *EVENT_KEY_PID = "PID";
constexpr const char *INVALID_EVENT_NAME = "INVALIDEVENTNAME";
const std::map<EventName, std::string> eventNameToStrMap_ = {
std::map<EventName, std::string>::value_type(EventName::START_ABILITY_ERROR, "START_ABILITY_ERROR"),
std::map<EventName, std::string>::value_type(EventName::TERMINATE_ABILITY_ERROR, "TERMINATE_ABILITY_ERROR"),
@@ -88,48 +92,12 @@ const std::map<EventName, std::string> eventNameToStrMap_ = {
void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
{
constexpr int32_t defaultVal = -1;
std::string name = ConvertEventName(eventName);
if (name == "INVALIDEVENTNAME") {
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
switch (eventName) {
case EventName::PROCESS_START:
if (eventInfo.extensionType == defaultVal) {
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_STARTUP_TIME, eventInfo.time,
EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
} else {
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_STARTUP_TIME, eventInfo.time,
EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName);
}
break;
case EventName::PROCESS_EXIT:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_EXIT_TIME, eventInfo.time,
EVENT_KEY_EXIT_RESULT, eventInfo.exitResult,
EVENT_KEY_EXIT_PID, eventInfo.pid);
break;
case EventName::APP_STARTUP_TYPE:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
@@ -142,33 +110,6 @@ void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
EVENT_KEY_START_TYPE, eventInfo.startType);
break;
case EventName::APP_FOREGROUND:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
break;
case EventName::APP_BACKGROUND:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
break;
case EventName::DRAWN_COMPLETED:
HILOG_INFO("HiSysEvent name: DRAWN_COMPLETED, bundleName: %{public}s, abilityName: %{public}s",
eventInfo.bundleName.c_str(), eventInfo.abilityName.c_str());
@@ -182,22 +123,6 @@ void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
break;
case EventName::APP_LAUNCH:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_VERSION_NAME, eventInfo.callerVersionName,
EVENT_KEY_CALLER_VERSION_CODE, eventInfo.callerVersionCode,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_STATE, eventInfo.callerState);
break;
default:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
@@ -215,7 +140,7 @@ void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type,
void EventReport::SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == "INVALIDEVENTNAME") {
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
@@ -293,36 +218,11 @@ void EventReport::SendAbilityEvent(const EventName &eventName, HiSysEventType ty
void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == "INVALIDEVENTNAME") {
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
switch (eventName) {
case EventName::DISCONNECT_SERVICE:
HiSysEventWrite(HiSysEvent::Domain::AAFWK, name, type);
break;
case EventName::CONNECT_SERVICE:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_USERID, eventInfo.userId,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName);
break;
case EventName::START_SERVICE:
case EventName::STOP_SERVICE:
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
type,
EVENT_KEY_USERID, eventInfo.userId,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType);
break;
case EventName::START_EXTENSION_ERROR:
case EventName::STOP_EXTENSION_ERROR:
case EventName::CONNECT_SERVICE_ERROR:
@@ -347,7 +247,7 @@ void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType
void EventReport::SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == "INVALIDEVENTNAME") {
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
@@ -388,13 +288,220 @@ void EventReport::SendKeyEvent(const EventName &eventName, HiSysEventType type,
}
}
void EventReport::SendAppLaunchEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_VERSION_NAME, eventInfo.callerVersionName,
EVENT_KEY_CALLER_VERSION_CODE, eventInfo.callerVersionCode,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_STATE, eventInfo.callerState);
}
void EventReport::SendAppForegroundEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
}
void EventReport::SendAppBackgroundEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_APP_PID, eventInfo.pid,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_VERSION_NAME, eventInfo.versionName,
EVENT_KEY_VERSION_CODE, eventInfo.versionCode,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_BUNDLE_TYPE, eventInfo.bundleType,
EVENT_KEY_PROCESS_TYPE, eventInfo.processType);
}
void EventReport::SendProcessStartEvent(const EventName &eventName, const EventInfo &eventInfo)
{
constexpr int32_t defaultVal = -1;
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
if (eventInfo.extensionType == defaultVal) {
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_STARTUP_TIME, eventInfo.time,
EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid);
} else {
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_STARTUP_TIME, eventInfo.time,
EVENT_KEY_STARTUP_ABILITY_TYPE, eventInfo.abilityType,
EVENT_KEY_STARTUP_EXTENSION_TYPE, eventInfo.extensionType,
EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName,
EVENT_KEY_CALLER_UID, eventInfo.callerUid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid);
}
}
void EventReport::SendProcessExitEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_EXIT_TIME, eventInfo.time,
EVENT_KEY_EXIT_RESULT, eventInfo.exitResult,
EVENT_KEY_EXIT_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType);
}
void EventReport::SendStartServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_TIME, eventInfo.time,
EVENT_KEY_USERID, eventInfo.userId,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
}
void EventReport::SendStopServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_USERID, eventInfo.userId,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
EVENT_KEY_EXTENSION_TYPE, eventInfo.extensionType,
EVENT_KEY_TIME, eventInfo.time,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
}
void EventReport::SendConnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(
HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_TIME, eventInfo.time,
EVENT_KEY_USERID, eventInfo.userId,
EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName,
EVENT_KEY_MODULE_NAME, eventInfo.moduleName,
EVENT_KEY_ABILITY_NAME, eventInfo.abilityName,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
}
void EventReport::SendDisconnectServiceEvent(const EventName &eventName, const EventInfo &eventInfo)
{
std::string name = ConvertEventName(eventName);
if (name == INVALID_EVENT_NAME) {
HILOG_ERROR("invalid eventName");
return;
}
HiSysEventWrite(HiSysEvent::Domain::AAFWK,
name,
HiSysEventType::BEHAVIOR,
EVENT_KEY_TIME, eventInfo.time,
EVENT_KEY_PID, eventInfo.pid,
EVENT_KEY_PROCESS_NAME, eventInfo.processName,
EVENT_KEY_CALLER_PROCESS_ID, eventInfo.callerPid,
EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName);
}
std::string EventReport::ConvertEventName(const EventName &eventName)
{
auto it = eventNameToStrMap_.find(eventName);
if (it != eventNameToStrMap_.end()) {
return it->second;
}
return "INVALIDEVENTNAME";
return INVALID_EVENT_NAME;
}
} // namespace AAFwk
} // namespace OHOS
test/unittest/ability_connect_manager_test/ability_connect_manager_test.cpp
+17
View File
@@ -3209,5 +3209,22 @@ HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_SignRestartAppFlag_001, Test
connectManager->serviceMap_.emplace("second", abilityRecord2);
connectManager->SignRestartAppFlag(bundleName);
}
/*
* Feature: AbilityConnectManager
* Function: BuildEventInfo
* CaseDescription: Verify AbilityConnectManager BuildEventInfo
*/
HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_BuildEventInfo_001, TestSize.Level1)
{
std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
ASSERT_NE(connectManager, nullptr);
connectManager->BuildEventInfo(nullptr);
std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
connectManager->BuildEventInfo(abilityRecord);
abilityRecord->SetCreateByConnectMode(true);
connectManager->BuildEventInfo(abilityRecord);
}
} // namespace AAFwk
} // namespace OHOS
test/unittest/app_mgr_service_inner_tdd_test/app_mgr_service_inner_tdd_test.cpp
+16 -2
View File
@@ -348,11 +348,25 @@ HWTEST_F(AppMgrServiceInnerTest, SendProcessExitEvent_001, TestSize.Level1)
TAG_LOGI(AAFwkTag::TEST, "SendProcessExitEvent_001 start");
auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
EXPECT_NE(appMgrServiceInner, nullptr);
pid_t pid = -1;
appMgrServiceInner->SendProcessExitEvent(pid);
std::shared_ptr<AppRunningRecord> appRecord;
appMgrServiceInner->SendProcessExitEvent(appRecord);
TAG_LOGI(AAFwkTag::TEST, "SendProcessExitEvent_001 end");
}
/**
* @tc.name: SendProcessExitEvent_002
* @tc.desc: Verify that the SendProcessExitEvent interface calls normally
* @tc.type: FUNC
*/
HWTEST_F(AppMgrServiceInnerTest, SendProcessExitEvent_002, TestSize.Level1)
{
TAG_LOGI(AAFwkTag::TEST, "SendProcessExitEvent_002 start");
auto appMgrServiceInner = std::make_shared<AppMgrServiceInner>();
EXPECT_NE(appMgrServiceInner, nullptr);
appMgrServiceInner->SendProcessExitEvent(nullptr);
TAG_LOGI(AAFwkTag::TEST, "SendProcessExitEvent_002 end");
}
/**
* @tc.name: CheckIsolationMode_001
* @tc.desc: CheckIsolationMode
test/unittest/event_report_test/event_report_test.cpp
+238 -53
View File
@@ -63,8 +63,8 @@ HWTEST_F(EventReportTest, SendAppEvent_0100, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendAppEvent_0200, TestSize.Level0)
{
EventName eventName = EventName::PROCESS_START;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_START");
EventName eventName = EventName::APP_STARTUP_TYPE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_STARTUP_TYPE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendAppEvent(eventName, type, eventInfo);
@@ -78,8 +78,8 @@ HWTEST_F(EventReportTest, SendAppEvent_0200, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendAppEvent_0300, TestSize.Level0)
{
EventName eventName = EventName::PROCESS_START;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_START");
EventName eventName = EventName::DRAWN_COMPLETED;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "DRAWN_COMPLETED");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
eventInfo.extensionType = 0;
@@ -93,21 +93,6 @@ HWTEST_F(EventReportTest, SendAppEvent_0300, TestSize.Level0)
* @tc.require: issueI6HXXS
*/
HWTEST_F(EventReportTest, SendAppEvent_0400, TestSize.Level0)
{
EventName eventName = EventName::PROCESS_EXIT;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_EXIT");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendAppEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendAppEvent_0500
* @tc.desc: Check SendAppEvent Test
* @tc.type: FUNC
* @tc.require: issueI67H0J
*/
HWTEST_F(EventReportTest, SendAppEvent_0500, TestSize.Level0)
{
EventName eventName = EventName::APP_ATTACH;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_ATTACH");
@@ -307,9 +292,9 @@ HWTEST_F(EventReportTest, SendExtensionEvent_0100, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0200, TestSize.Level0)
{
EventName eventName = EventName::DISCONNECT_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventName eventName = EventName::START_EXTENSION_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_EXTENSION_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
@@ -322,9 +307,9 @@ HWTEST_F(EventReportTest, SendExtensionEvent_0200, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0300, TestSize.Level0)
{
EventName eventName = EventName::CONNECT_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventName eventName = EventName::STOP_EXTENSION_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_EXTENSION_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
@@ -337,9 +322,9 @@ HWTEST_F(EventReportTest, SendExtensionEvent_0300, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0400, TestSize.Level0)
{
EventName eventName = EventName::START_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_SERVICE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventName eventName = EventName::CONNECT_SERVICE_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
@@ -352,9 +337,9 @@ HWTEST_F(EventReportTest, SendExtensionEvent_0400, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0500, TestSize.Level0)
{
EventName eventName = EventName::STOP_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_SERVICE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventName eventName = EventName::DISCONNECT_SERVICE_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
@@ -367,56 +352,256 @@ HWTEST_F(EventReportTest, SendExtensionEvent_0500, TestSize.Level0)
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0600, TestSize.Level0)
{
EventName eventName = EventName::START_EXTENSION_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_EXTENSION_ERROR");
EventName eventName = EventName::START_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_SERVICE");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendExtensionEvent_0700
* @tc.desc: Check SendExtensionEvent Test
* @tc.name: SendKeyEvent_0100
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI67H0J
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0700, TestSize.Level0)
HWTEST_F(EventReportTest, SendKeyEvent_0100, TestSize.Level0)
{
EventName eventName = EventName::STOP_EXTENSION_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_EXTENSION_ERROR");
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
HiSysEventType type = HiSysEventType::FAULT;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendExtensionEvent_0800
* @tc.desc: Check SendExtensionEvent Test
* @tc.name: SendKeyEvent_0200
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI67H0J
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0800, TestSize.Level0)
HWTEST_F(EventReportTest, SendKeyEvent_0200, TestSize.Level0)
{
EventName eventName = EventName::CONNECT_SERVICE_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventName eventName = EventName::GRANT_URI_PERMISSION;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "GRANT_URI_PERMISSION");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendExtensionEvent_0900
* @tc.desc: Check SendExtensionEvent Test
* @tc.name: SendKeyEvent_0300
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI67H0J
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendExtensionEvent_0900, TestSize.Level0)
HWTEST_F(EventReportTest, SendKeyEvent_0300, TestSize.Level0)
{
EventName eventName = EventName::DISCONNECT_SERVICE_ERROR;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE_ERROR");
HiSysEventType type = HiSysEventType::FAULT;
EventName eventName = EventName::FA_SHOW_ON_LOCK;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "FA_SHOW_ON_LOCK");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendKeyEvent_0400
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendKeyEvent_0400, TestSize.Level0)
{
EventName eventName = EventName::START_PRIVATE_ABILITY;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_PRIVATE_ABILITY");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendKeyEvent_0500
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendKeyEvent_0500, TestSize.Level0)
{
EventName eventName = EventName::RESTART_PROCESS_BY_SAME_APP;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "RESTART_PROCESS_BY_SAME_APP");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendKeyEvent_0600
* @tc.desc: Check SendKeyEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendKeyEvent_0600, TestSize.Level0)
{
EventName eventName = EventName::START_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_SERVICE");
HiSysEventType type = HiSysEventType::BEHAVIOR;
EventInfo eventInfo;
EventReport::SendExtensionEvent(eventName, type, eventInfo);
}
/**
* @tc.name: SendAppLaunchEvent_0100
* @tc.desc: Check SendAppLaunchEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendAppLaunchEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendAppLaunchEvent(eventName, eventInfo);
eventName = EventName::APP_LAUNCH;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_LAUNCH");
EventReport::SendAppLaunchEvent(eventName, eventInfo);
}
/**
* @tc.name: SendAppForegroundEvent_0100
* @tc.desc: Check SendAppForegroundEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendAppForegroundEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendAppForegroundEvent(eventName, eventInfo);
eventName = EventName::APP_FOREGROUND;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_FOREGROUND");
EventReport::SendAppForegroundEvent(eventName, eventInfo);
}
/**
* @tc.name: SendAppBackgroundEvent_0100
* @tc.desc: Check SendAppBackgroundEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendAppBackgroundEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendAppBackgroundEvent(eventName, eventInfo);
eventName = EventName::APP_BACKGROUND;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "APP_BACKGROUND");
EventReport::SendAppBackgroundEvent(eventName, eventInfo);
}
/**
* @tc.name: SendProcessStartEvent_0100
* @tc.desc: Check SendProcessStartEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendProcessStartEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendProcessStartEvent(eventName, eventInfo);
eventName = EventName::PROCESS_START;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_START");
EventReport::SendProcessStartEvent(eventName, eventInfo);
eventInfo.extensionType = 0;
EventReport::SendProcessStartEvent(eventName, eventInfo);
}
/**
* @tc.name: SendProcessExitEvent_0100
* @tc.desc: Check SendProcessExitEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendProcessExitEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendProcessExitEvent(eventName, eventInfo);
eventName = EventName::PROCESS_EXIT;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "PROCESS_EXIT");
EventReport::SendProcessExitEvent(eventName, eventInfo);
}
/**
* @tc.name: SendStartServiceEvent_0100
* @tc.desc: Check SendStartServiceEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendStartServiceEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendStartServiceEvent(eventName, eventInfo);
eventName = EventName::START_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "START_SERVICE");
EventReport::SendStartServiceEvent(eventName, eventInfo);
}
/**
* @tc.name: SendStopServiceEvent_0100
* @tc.desc: Check SendStopServiceEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendStopServiceEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendStopServiceEvent(eventName, eventInfo);
eventName = EventName::STOP_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "STOP_SERVICE");
EventReport::SendStopServiceEvent(eventName, eventInfo);
}
/**
* @tc.name: SendConnectServiceEvent_0100
* @tc.desc: Check SendConnectServiceEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendConnectServiceEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendConnectServiceEvent(eventName, eventInfo);
eventName = EventName::CONNECT_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "CONNECT_SERVICE");
EventReport::SendConnectServiceEvent(eventName, eventInfo);
}
/**
* @tc.name: SendDisconnectServiceEvent_0100
* @tc.desc: Check SendDisconnectServiceEvent Test
* @tc.type: FUNC
* @tc.require: issueI99FZY
*/
HWTEST_F(EventReportTest, SendDisconnectServiceEvent_0100, TestSize.Level0)
{
EventName eventName = static_cast<EventName>(-1);
EXPECT_EQ(EventReport::ConvertEventName(eventName), "INVALIDEVENTNAME");
EventInfo eventInfo;
EventReport::SendDisconnectServiceEvent(eventName, eventInfo);
eventName = EventName::DISCONNECT_SERVICE;
EXPECT_EQ(EventReport::ConvertEventName(eventName), "DISCONNECT_SERVICE");
EventReport::SendDisconnectServiceEvent(eventName, eventInfo);
}
} // namespace AAFwk
} // namespace OHOS