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 "udmf_conversion.h"
17 #include "unified_data.h"
18 #include "application_defined_record.h"
19 #include "audio.h"
20 #include "file.h"
21 #include "folder.h"
22 #include "html.h"
23 #include "image.h"
24 #include "link.h"
25 #include "plain_text.h"
26 #include "system_defined_appitem.h"
27 #include "system_defined_form.h"
28 #include "system_defined_pixelmap.h"
29 #include "system_defined_record.h"
30 #include "text.h"
31 #include "unified_record.h"
32 #include "video.h"
33 #include <memory>
34 #include <utility>
35
36 namespace OHOS::UDMF {
37
SetValueWhenNotUds(std::shared_ptr<UnifiedRecord> record)38 void UdmfConversion::SetValueWhenNotUds(std::shared_ptr<UnifiedRecord> record)
39 {
40 if (!std::holds_alternative<std::shared_ptr<Object>>(record->GetValue())) {
41 return;
42 }
43 auto object = std::get<std::shared_ptr<Object>>(record->GetValue());
44 auto it = object->value_.find("VALUE_TYPE");
45 if (it == object->value_.end()) {
46 return;
47 }
48 if (std::holds_alternative<std::shared_ptr<Object>>(it->second)) {
49 return;
50 }
51 record->SetValue(it->second);
52 }
53
ConvertRecordToSubclass(std::shared_ptr<UnifiedRecord> & record)54 void UdmfConversion::ConvertRecordToSubclass(std::shared_ptr<UnifiedRecord> &record)
55 {
56 auto type = record->GetType();
57 auto value = record->GetOriginValue();
58 auto uid = record->GetUid();
59 auto entries = record->GetInnerEntries();
60 auto utdId = record->GetUtdId();
61 switch (type) {
62 case UDType::TEXT: {
63 record = std::make_shared<Text>(type, value);
64 break;
65 }
66 case UDType::PLAIN_TEXT: {
67 record = std::make_shared<PlainText>(type, value);
68 break;
69 }
70 case UDType::HTML: {
71 record = std::make_shared<Html>(type, value);
72 break;
73 }
74 case UDType::HYPERLINK: {
75 record = std::make_shared<Link>(type, value);
76 break;
77 }
78 case UDType::FILE: {
79 record = std::make_shared<File>(type, value);
80 break;
81 }
82 case UDType::IMAGE: {
83 record = std::make_shared<Image>(type, value);
84 break;
85 }
86 case UDType::VIDEO: {
87 record = std::make_shared<Video>(type, value);
88 break;
89 }
90 case UDType::AUDIO: {
91 record = std::make_shared<Audio>(type, value);
92 break;
93 }
94 case UDType::FOLDER: {
95 record = std::make_shared<Folder>(type, value);
96 break;
97 }
98 case UDType::SYSTEM_DEFINED_RECORD: {
99 record = std::make_shared<SystemDefinedRecord>(type, value);
100 break;
101 }
102 case UDType::SYSTEM_DEFINED_FORM: {
103 record = std::make_shared<SystemDefinedForm>(type, value);
104 break;
105 }
106 case UDType::SYSTEM_DEFINED_APP_ITEM: {
107 record = std::make_shared<SystemDefinedAppItem>(type, value);
108 break;
109 }
110 case UDType::SYSTEM_DEFINED_PIXEL_MAP: {
111 record = std::make_shared<SystemDefinedPixelMap>(type, value);
112 break;
113 }
114 case UDType::APPLICATION_DEFINED_RECORD: {
115 record = std::make_shared<ApplicationDefinedRecord>(type, value);
116 break;
117 }
118 default: {
119 record = std::make_shared<UnifiedRecord>(type, value);
120 }
121 }
122 record->SetUid(uid);
123 record->SetUtdId(utdId);
124 record->SetInnerEntries(entries);
125 SetValueWhenNotUds(record);
126 }
127
ConvertRecordToSubclass(UnifiedData & data)128 void UdmfConversion::ConvertRecordToSubclass(UnifiedData &data)
129 {
130 std::vector<std::shared_ptr<UnifiedRecord>> records;
131 for (auto &record : data.GetRecords()) {
132 ConvertRecordToSubclass(record);
133 records.push_back(std::move(record));
134 }
135 data.SetRecords(records);
136 }
137
ConvertRecordToSubclass(std::vector<UnifiedData> & datas)138 void UdmfConversion::ConvertRecordToSubclass(std::vector<UnifiedData> &datas)
139 {
140 for (auto &data : datas) {
141 ConvertRecordToSubclass(data);
142 }
143 }
144
InitValueObject(UnifiedData & data)145 void UdmfConversion::InitValueObject(UnifiedData &data)
146 {
147 for (auto &record : data.GetRecords()) {
148 record->InitObject();
149 }
150 }
151
InitValueObject(std::vector<UnifiedData> & datas)152 void UdmfConversion::InitValueObject(std::vector<UnifiedData> &datas)
153 {
154 for (auto &data : datas) {
155 InitValueObject(data);
156 }
157 }
158 }
159