• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#include "{header}.h"
2
3{{ if readwrite- }}
4#include <unistd.h>
5#include "aconfig_storage/aconfig_storage_read_api.hpp"
6#include <android/log.h>
7#define LOG_TAG "aconfig_cpp_codegen"
8#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
9{{ -endif }}
10
11{{ if is_test_mode }}
12#include <unordered_map>
13#include <string>
14{{ -else- }}
15{{ if readwrite- }}
16#include <vector>
17{{ -endif }}
18{{ -endif }}
19
20namespace {cpp_namespace} \{
21
22{{ if is_test_mode }}
23    class flag_provider : public flag_provider_interface \{
24    private:
25        std::unordered_map<std::string, bool> overrides_;
26
27    {{ if readwrite- }}
28        uint32_t boolean_start_index_;
29
30        std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
31
32        bool package_exists_in_storage_;
33    {{ -endif }}
34
35    public:
36    {{ if readwrite- }}
37        flag_provider()
38            : overrides_()
39            , boolean_start_index_()
40            , flag_value_file_(nullptr)
41            , package_exists_in_storage_(true) \{
42
43            auto package_map_file = aconfig_storage::get_mapped_file(
44                 "{container}",
45                 aconfig_storage::StorageFileType::package_map);
46
47            if (!package_map_file.ok()) \{
48                ALOGE("error: failed to get package map file: %s", package_map_file.error().c_str());
49                package_exists_in_storage_ = false;
50                return;
51            }
52
53            auto context = aconfig_storage::get_package_read_context(
54                **package_map_file, "{package}");
55
56            if (!context.ok()) \{
57                ALOGE("error: failed to get package read context: %s", context.error().c_str());
58                package_exists_in_storage_ = false;
59                return;
60            }
61
62            if (!(context->package_exists)) \{
63                package_exists_in_storage_ = false;
64                return;
65            }
66
67            // cache package boolean flag start index
68            boolean_start_index_ = context->boolean_start_index;
69
70            // unmap package map file and free memory
71            delete *package_map_file;
72
73            auto flag_value_file = aconfig_storage::get_mapped_file(
74                "{container}",
75                aconfig_storage::StorageFileType::flag_val);
76            if (!flag_value_file.ok()) \{
77                ALOGE("error: failed to get flag value file: %s", flag_value_file.error().c_str());
78                package_exists_in_storage_ = false;
79                return;
80            }
81
82            // cache flag value file
83            flag_value_file_ = std::unique_ptr<aconfig_storage::MappedStorageFile>(
84                *flag_value_file);
85
86        }
87    {{ -else }}
88        flag_provider()
89            : overrides_()
90        \{}
91    {{ -endif }}
92
93    {{ for item in class_elements }}
94        virtual bool {item.flag_name}() override \{
95            auto it = overrides_.find("{item.flag_name}");
96            if (it != overrides_.end()) \{
97                return it->second;
98            } else \{
99                {{ if item.readwrite- }}
100                if (!package_exists_in_storage_) \{
101                    return {item.default_value};
102                }
103
104                auto value = aconfig_storage::get_boolean_flag_value(
105                    *flag_value_file_,
106                    boolean_start_index_ + {item.flag_offset});
107
108                if (!value.ok()) \{
109                    ALOGE("error: failed to read flag value: %s", value.error().c_str());
110                    return {item.default_value};
111                } else \{
112                    return *value;
113                }
114                {{ -else }}
115                return {item.default_value};
116                {{ -endif }}
117            }
118        }
119
120        virtual void {item.flag_name}(bool val) override \{
121            overrides_["{item.flag_name}"] = val;
122        }
123    {{ endfor }}
124
125        virtual void reset_flags() override \{
126            overrides_.clear();
127        }
128    };
129
130{{ -else- }}
131
132    class flag_provider : public flag_provider_interface \{
133    public:
134
135        {{ if readwrite- }}
136        flag_provider()
137            : cache_({readwrite_count}, -1)
138            , boolean_start_index_()
139            , flag_value_file_(nullptr)
140            , package_exists_in_storage_(true) \{
141
142            auto package_map_file = aconfig_storage::get_mapped_file(
143                 "{container}",
144                 aconfig_storage::StorageFileType::package_map);
145            if (!package_map_file.ok()) \{
146                ALOGE("error: failed to get package map file: %s", package_map_file.error().c_str());
147                package_exists_in_storage_ = false;
148                return;
149            }
150
151            auto context = aconfig_storage::get_package_read_context(
152                **package_map_file, "{package}");
153            if (!context.ok()) \{
154                ALOGE("error: failed to get package read context: %s", context.error().c_str());
155                package_exists_in_storage_ = false;
156                return;
157            }
158
159            if (!(context->package_exists)) \{
160                package_exists_in_storage_ = false;
161                return;
162            }
163
164            // cache package boolean flag start index
165            boolean_start_index_ = context->boolean_start_index;
166
167            // unmap package map file and free memory
168            delete *package_map_file;
169
170            auto flag_value_file = aconfig_storage::get_mapped_file(
171                "{container}",
172                aconfig_storage::StorageFileType::flag_val);
173            if (!flag_value_file.ok()) \{
174                ALOGE("error: failed to get flag value file: %s", flag_value_file.error().c_str());
175                package_exists_in_storage_ = false;
176                return;
177            }
178
179            // cache flag value file
180            flag_value_file_ = std::unique_ptr<aconfig_storage::MappedStorageFile>(
181                *flag_value_file);
182
183        }
184        {{ -endif }}
185
186        {{ -for item in class_elements }}
187        virtual bool {item.flag_name}() override \{
188            {{ -if item.readwrite }}
189            if (cache_[{item.readwrite_idx}] == -1) \{
190                if (!package_exists_in_storage_) \{
191                    return {item.default_value};
192                }
193
194                auto value = aconfig_storage::get_boolean_flag_value(
195                    *flag_value_file_,
196                    boolean_start_index_ + {item.flag_offset});
197
198                if (!value.ok()) \{
199                    ALOGE("error: failed to read flag value: %s", value.error().c_str());
200                    return {item.default_value};
201                }
202
203                cache_[{item.readwrite_idx}] = *value;
204            }
205            return cache_[{item.readwrite_idx}];
206            {{ -else }}
207            {{ -if item.is_fixed_read_only }}
208            return {package_macro}_{item.flag_macro};
209            {{ -else }}
210            return {item.default_value};
211            {{ -endif }}
212            {{ -endif }}
213        }
214        {{ -endfor }}
215
216    {{ if readwrite- }}
217    private:
218        std::vector<int8_t> cache_ = std::vector<int8_t>({readwrite_count}, -1);
219
220        uint32_t boolean_start_index_;
221
222        std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
223
224        bool package_exists_in_storage_;
225    {{ -endif }}
226
227    };
228
229{{ -endif }}
230
231std::unique_ptr<flag_provider_interface> provider_ =
232    std::make_unique<flag_provider>();
233}
234
235{{ for item in class_elements }}
236bool {header}_{item.flag_name}() \{
237    {{ -if is_test_mode }}
238    return {cpp_namespace}::{item.flag_name}();
239    {{ -else }}
240    {{ -if item.readwrite }}
241    return {cpp_namespace}::{item.flag_name}();
242    {{ -else }}
243    {{ -if item.is_fixed_read_only }}
244    return {package_macro}_{item.flag_macro};
245    {{ -else }}
246    return {item.default_value};
247    {{ -endif }}
248    {{ -endif }}
249    {{ -endif }}
250}
251
252{{ -if is_test_mode }}
253void set_{header}_{item.flag_name}(bool val) \{
254    {cpp_namespace}::{item.flag_name}(val);
255}
256{{ -endif }}
257{{ endfor }}
258
259{{ -if is_test_mode }}
260void {header}_reset_flags() \{
261     {cpp_namespace}::reset_flags();
262}
263{{ -endif }}
264