1 /*
2  * Copyright (c) 2024 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 "app_event_task_storage.h"
17 
18 #include "hiview_logger.h"
19 #include "sql_util.h"
20 
21 namespace OHOS {
22 namespace HiviewDFX {
23 DEFINE_LOG_TAG("AppEventTaskStorage");
24 namespace {
25 const std::string TABLE_NAME_TASK = "unified_collection_task";
26 const std::string COLUMN_ID = "id";
27 const std::string COLUMN_TASK_DATE = "task_date";
28 const std::string COLUMN_TASK_TYPE = "task_type";
29 const std::string COLUMN_UID = "uid";
30 const std::string COLUMN_PID = "pid";
31 const std::string COLUMN_BUNDLE_NAME = "bundle_name";
32 const std::string COLUMN_BUNDLE_VERSION = "bundle_version";
33 const std::string COLUMN_START_TIME = "start_time";
34 const std::string COLUMN_FINISH_TIME = "finish_time";
35 const std::string COLUMN_RESOURCE_PATH = "resource_path";
36 const std::string COLUMN_RESOURCE_SIZE = "resource_size";
37 const std::string COLUMN_COST_CPU = "cost_cpu";
38 const std::string COLUMN_STATE = "state";
39 
InnerCreateAppTaskTable(std::shared_ptr<NativeRdb::RdbStore> dbStore)40 bool InnerCreateAppTaskTable(std::shared_ptr<NativeRdb::RdbStore> dbStore)
41 {
42     /**
43      * table: unified_collection_task
44      *
45      * describe: store data that app task
46      * |-----|-----------|-----------|-------|-------|-------------|----------------|------------|-------------|
47      * |  id | task_date | task_type | uid   | pid   | bundle_name | bundle_version | start_time | finish_time |
48      * |-----|-----------|-----------|-------|-------|-------------|----------------|------------|-------------|
49      * | INT |   INT64   |    INT8   | INT32 | INT32 |      TEXT   | TEXT           |  INT64     | INT64       |
50      * |-----|-----------|-----------|-------|-------|-------------|----------------|------------|-------------|
51      *
52      * |---------------|---------------|----------|-------|
53      * | resource_path | resource_size | cost_cpu | state |
54      * |---------------|---------------|----------|-------|
55      * | TEXT          | INT32         | REAL     | INT32 |
56      * |---------------|---------------|----------|-------|
57      */
58     const std::vector<std::pair<std::string, std::string>> fields = {
59         {COLUMN_TASK_DATE, SqlUtil::COLUMN_TYPE_INT},
60         {COLUMN_TASK_TYPE, SqlUtil::COLUMN_TYPE_INT},
61         {COLUMN_UID, SqlUtil::COLUMN_TYPE_INT},
62         {COLUMN_PID, SqlUtil::COLUMN_TYPE_INT},
63         {COLUMN_BUNDLE_NAME, SqlUtil::COLUMN_TYPE_STR},
64         {COLUMN_BUNDLE_VERSION, SqlUtil::COLUMN_TYPE_STR},
65         {COLUMN_START_TIME, SqlUtil::COLUMN_TYPE_INT},
66         {COLUMN_FINISH_TIME, SqlUtil::COLUMN_TYPE_STR},
67         {COLUMN_RESOURCE_PATH, SqlUtil::COLUMN_TYPE_INT},
68         {COLUMN_RESOURCE_SIZE, SqlUtil::COLUMN_TYPE_INT},
69         {COLUMN_COST_CPU, SqlUtil::COLUMN_TYPE_DOU},
70         {COLUMN_STATE, SqlUtil::COLUMN_TYPE_INT},
71     };
72     HIVIEW_LOGI("create table app task=%{public}s", TABLE_NAME_TASK.c_str());
73     std::string sql = SqlUtil::GenerateCreateSql(TABLE_NAME_TASK, fields);
74     if (dbStore->ExecuteSql(sql) != NativeRdb::E_OK) {
75         HIVIEW_LOGE("failed to create app task table, sql=%{public}s", sql.c_str());
76         return false;
77     }
78     return true;
79 }
80 
InnerGetAppTaskCondition(int32_t uid,int32_t eventDate,NativeRdb::AbsRdbPredicates & predicates)81 void InnerGetAppTaskCondition(int32_t uid, int32_t eventDate, NativeRdb::AbsRdbPredicates &predicates)
82 {
83     predicates.EqualTo(COLUMN_UID, uid);
84     predicates.EqualTo(COLUMN_TASK_DATE, eventDate);
85 }
86 
InnerGetAppTask(std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet,AppEventTask & appEventTask)87 bool InnerGetAppTask(std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet, AppEventTask &appEventTask)
88 {
89     while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
90         if (resultSet->GetLong(0, appEventTask.id_) != NativeRdb::E_OK) {
91             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_ID.c_str());
92         }
93         if (resultSet->GetLong(1, appEventTask.taskDate_) != NativeRdb::E_OK) { // 1: task date
94             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_TASK_DATE.c_str());
95         }
96         if (resultSet->GetInt(2, appEventTask.taskType_) != NativeRdb::E_OK) { // 2: task type
97             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_TASK_TYPE.c_str());
98         }
99         if (resultSet->GetInt(3, appEventTask.uid_) != NativeRdb::E_OK) { // 3: uid
100             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_UID.c_str());
101         }
102         if (resultSet->GetInt(4, appEventTask.pid_) != NativeRdb::E_OK) { // 4: pid
103             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_PID.c_str());
104         }
105         if (resultSet->GetString(5, appEventTask.bundleName_) != NativeRdb::E_OK) { // 5: bundle name
106             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_BUNDLE_NAME.c_str());
107         }
108         if (resultSet->GetString(6, appEventTask.bundleVersion_) != NativeRdb::E_OK) { // 6: bundle version
109             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_BUNDLE_VERSION.c_str());
110         }
111         if (resultSet->GetLong(7, appEventTask.startTime_) != NativeRdb::E_OK) { // 7: start time
112             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_START_TIME.c_str());
113         }
114         if (resultSet->GetLong(8, appEventTask.finishTime_) != NativeRdb::E_OK) { // 8: finish time
115             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_FINISH_TIME.c_str());
116         }
117         if (resultSet->GetString(9, appEventTask.resourePath_) != NativeRdb::E_OK) { // 9: resource path
118             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_RESOURCE_PATH.c_str());
119         }
120         if (resultSet->GetInt(10, appEventTask.resourceSize_) != NativeRdb::E_OK) { // 10: resource size
121             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_RESOURCE_SIZE.c_str());
122         }
123         if (resultSet->GetDouble(11, appEventTask.costCpu_) != NativeRdb::E_OK) { // 11: cost cpu
124             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_COST_CPU.c_str());
125         }
126         if (resultSet->GetInt(12, appEventTask.state_) != NativeRdb::E_OK) { // 12: state of cpature trace
127             HIVIEW_LOGI("failed to get %{public}s from resultSet", COLUMN_STATE.c_str());
128         }
129         break;
130     }
131     return true;
132 }
133 
InnerQeuryAppTask(std::shared_ptr<NativeRdb::RdbStore> dbStore,NativeRdb::AbsRdbPredicates & predicates,AppEventTask & appEventTask)134 bool InnerQeuryAppTask(std::shared_ptr<NativeRdb::RdbStore> dbStore, NativeRdb::AbsRdbPredicates &predicates,
135     AppEventTask &appEventTask)
136 {
137     appEventTask.id_ = 0;
138     std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = dbStore->Query(predicates,
139         {
140             COLUMN_ID, COLUMN_TASK_DATE, COLUMN_TASK_TYPE, COLUMN_UID, COLUMN_PID,
141             COLUMN_BUNDLE_NAME, COLUMN_BUNDLE_VERSION, COLUMN_START_TIME, COLUMN_FINISH_TIME,
142             COLUMN_RESOURCE_PATH, COLUMN_RESOURCE_SIZE, COLUMN_COST_CPU, COLUMN_STATE
143         });
144     if (resultSet == nullptr) {
145         HIVIEW_LOGI("failed to query app task table=%{public}s", TABLE_NAME_TASK.c_str());
146         return false;
147     }
148     return InnerGetAppTask(resultSet, appEventTask);
149 }
150 }
151 
AppEventTaskStorage(std::shared_ptr<NativeRdb::RdbStore> dbStore)152 AppEventTaskStorage::AppEventTaskStorage(std::shared_ptr<NativeRdb::RdbStore> dbStore):dbStore_(dbStore)
153 {}
154 
InitAppTask()155 bool AppEventTaskStorage::InitAppTask()
156 {
157     if (!InnerCreateAppTaskTable(dbStore_)) {
158         return false;
159     }
160     return true;
161 }
162 
GetAppEventTask(int32_t uid,int32_t eventDate,AppEventTask & appEventTask)163 bool AppEventTaskStorage::GetAppEventTask(int32_t uid, int32_t eventDate, AppEventTask &appEventTask)
164 {
165     NativeRdb::AbsRdbPredicates predicates(TABLE_NAME_TASK);
166     InnerGetAppTaskCondition(uid, eventDate, predicates);
167     return InnerQeuryAppTask(dbStore_, predicates, appEventTask);
168 }
169 
InsertAppEventTask(AppEventTask & appEventTask)170 bool AppEventTaskStorage::InsertAppEventTask(AppEventTask &appEventTask)
171 {
172     NativeRdb::ValuesBucket bucket;
173     bucket.PutLong(COLUMN_TASK_DATE, appEventTask.taskDate_);
174     bucket.PutInt(COLUMN_TASK_TYPE, appEventTask.taskType_);
175     bucket.PutInt(COLUMN_UID, appEventTask.uid_);
176     bucket.PutInt(COLUMN_PID, appEventTask.pid_);
177     bucket.PutString(COLUMN_BUNDLE_NAME, appEventTask.bundleName_);
178     bucket.PutString(COLUMN_BUNDLE_VERSION, appEventTask.bundleVersion_);
179     bucket.PutLong(COLUMN_START_TIME, appEventTask.startTime_);
180     bucket.PutLong(COLUMN_FINISH_TIME, appEventTask.finishTime_);
181     bucket.PutString(COLUMN_RESOURCE_PATH, appEventTask.resourePath_);
182     bucket.PutInt(COLUMN_RESOURCE_SIZE, appEventTask.resourceSize_);
183     bucket.PutDouble(COLUMN_COST_CPU, appEventTask.costCpu_);
184     bucket.PutInt(COLUMN_STATE, appEventTask.state_);
185     int ret = dbStore_->Insert(appEventTask.id_, TABLE_NAME_TASK, bucket);
186     if (ret != NativeRdb::E_OK) {
187         HIVIEW_LOGE("failed to insert app event task, ret=%{public}d, uid=%{public}d", ret, appEventTask.uid_);
188         return false;
189     }
190     return true;
191 }
192 
RemoveAppEventTask(int32_t eventDate)193 void AppEventTaskStorage::RemoveAppEventTask(int32_t eventDate)
194 {
195     NativeRdb::AbsRdbPredicates predicates(TABLE_NAME_TASK);
196     predicates.LessThan(COLUMN_TASK_DATE, eventDate);
197     int32_t deleteRows = 0;
198     int ret = dbStore_->Delete(deleteRows, predicates);
199     if (ret != NativeRdb::E_OK) {
200         HIVIEW_LOGE("failed to insert app event task, ret=%{public}d", ret);
201     }
202 }
203 } // namespace HiviewDFX
204 } // namespace OHOS
205