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 auto utdId2 = record->GetUtdId2();
62 auto uris = record->GetUris();
63 switch (type) {
64 case UDType::TEXT: {
65 record = std::make_shared<Text>(type, value);
66 break;
67 }
68 case UDType::PLAIN_TEXT: {
69 record = std::make_shared<PlainText>(type, value);
70 break;
71 }
72 case UDType::HTML: {
73 record = std::make_shared<Html>(type, value);
74 break;
75 }
76 case UDType::HYPERLINK: {
77 record = std::make_shared<Link>(type, value);
78 break;
79 }
80 case UDType::FILE: {
81 record = std::make_shared<File>(type, value);
82 break;
83 }
84 case UDType::IMAGE: {
85 record = std::make_shared<Image>(type, value);
86 break;
87 }
88 case UDType::VIDEO: {
89 record = std::make_shared<Video>(type, value);
90 break;
91 }
92 case UDType::AUDIO: {
93 record = std::make_shared<Audio>(type, value);
94 break;
95 }
96 case UDType::FOLDER: {
97 record = std::make_shared<Folder>(type, value);
98 break;
99 }
100 case UDType::SYSTEM_DEFINED_RECORD: {
101 record = std::make_shared<SystemDefinedRecord>(type, value);
102 break;
103 }
104 case UDType::SYSTEM_DEFINED_FORM: {
105 record = std::make_shared<SystemDefinedForm>(type, value);
106 break;
107 }
108 case UDType::SYSTEM_DEFINED_APP_ITEM: {
109 record = std::make_shared<SystemDefinedAppItem>(type, value);
110 break;
111 }
112 case UDType::SYSTEM_DEFINED_PIXEL_MAP: {
113 record = std::make_shared<SystemDefinedPixelMap>(type, value);
114 break;
115 }
116 case UDType::APPLICATION_DEFINED_RECORD: {
117 record = std::make_shared<ApplicationDefinedRecord>(type, value);
118 break;
119 }
120 default: {
121 record = std::make_shared<UnifiedRecord>(type, value);
122 }
123 }
124 record->SetUid(uid);
125 record->SetUtdId(utdId);
126 record->SetUtdId2(utdId2);
127 record->SetInnerEntries(entries);
128 record->SetUris(uris);
129 SetValueWhenNotUds(record);
130 }
131
ConvertRecordToSubclass(UnifiedData & data)132 void UdmfConversion::ConvertRecordToSubclass(UnifiedData &data)
133 {
134 std::vector<std::shared_ptr<UnifiedRecord>> records;
135 for (auto &record : data.GetRecords()) {
136 ConvertRecordToSubclass(record);
137 records.push_back(std::move(record));
138 }
139 data.SetRecords(records);
140 }
141
ConvertRecordToSubclass(std::vector<UnifiedData> & datas)142 void UdmfConversion::ConvertRecordToSubclass(std::vector<UnifiedData> &datas)
143 {
144 for (auto &data : datas) {
145 ConvertRecordToSubclass(data);
146 }
147 }
148
InitValueObject(UnifiedData & data)149 void UdmfConversion::InitValueObject(UnifiedData &data)
150 {
151 for (auto &record : data.GetRecords()) {
152 record->InitObject();
153 }
154 }
155
InitValueObject(std::vector<UnifiedData> & datas)156 void UdmfConversion::InitValueObject(std::vector<UnifiedData> &datas)
157 {
158 for (auto &data : datas) {
159 InitValueObject(data);
160 }
161 }
162 }
163