• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#include "{header}.h"
2
3{{ if allow_instrumentation }}
4#include <sys/stat.h>
5#include "aconfig_storage/aconfig_storage_read_api.hpp"
6#include <android/log.h>
7
8#define ALOGI(msg, ...)                                                        \
9  __android_log_print(ANDROID_LOG_INFO, "AconfigTestMission1", (msg), __VA_ARGS__)
10
11{{ endif }}
12
13{{ if readwrite- }}
14#include <server_configurable_flags/get_flags.h>
15{{ endif }}
16{{ if is_test_mode }}
17#include <unordered_map>
18#include <string>
19{{ -else- }}
20{{ if readwrite- }}
21#include <vector>
22{{ -endif }}
23{{ -endif }}
24
25namespace {cpp_namespace} \{
26
27{{ if is_test_mode }}
28    class flag_provider : public flag_provider_interface \{
29    private:
30        std::unordered_map<std::string, bool> overrides_;
31
32    public:
33        flag_provider()
34            : overrides_()
35        \{}
36
37{{ for item in class_elements }}
38        virtual bool {item.flag_name}() override \{
39            auto it = overrides_.find("{item.flag_name}");
40              if (it != overrides_.end()) \{
41                  return it->second;
42            } else \{
43              {{ if item.readwrite- }}
44              return server_configurable_flags::GetServerConfigurableFlag(
45                  "aconfig_flags.{item.device_config_namespace}",
46                  "{item.device_config_flag}",
47                  "{item.default_value}") == "true";
48              {{ -else }}
49                  return {item.default_value};
50              {{ -endif }}
51            }
52        }
53
54        virtual void {item.flag_name}(bool val) override \{
55            overrides_["{item.flag_name}"] = val;
56        }
57{{ endfor }}
58
59        virtual void reset_flags() override \{
60            overrides_.clear();
61        }
62    };
63
64{{ -else- }}
65
66    class flag_provider : public flag_provider_interface \{
67    public:
68
69        {{ -for item in class_elements }}
70
71        virtual bool {item.flag_name}() override \{
72            {{ -if item.readwrite }}
73            if (cache_[{item.readwrite_idx}] == -1) \{
74                cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
75                    "aconfig_flags.{item.device_config_namespace}",
76                    "{item.device_config_flag}",
77                    "{item.default_value}") == "true";
78            }
79            return cache_[{item.readwrite_idx}];
80            {{ -else }}
81            {{ -if item.is_fixed_read_only }}
82            return {package_macro}_{item.flag_macro};
83            {{ -else }}
84            return {item.default_value};
85            {{ -endif }}
86            {{ -endif }}
87        }
88        {{ -endfor }}
89    {{ if readwrite- }}
90    private:
91        std::vector<int8_t> cache_ = std::vector<int8_t>({readwrite_count}, -1);
92    {{ -endif }}
93    };
94
95
96{{ -endif }}
97
98std::unique_ptr<flag_provider_interface> provider_ =
99    std::make_unique<flag_provider>();
100}
101
102{{ for item in class_elements }}
103bool {header}_{item.flag_name}() \{
104    {{ -if is_test_mode }}
105    return {cpp_namespace}::{item.flag_name}();
106    {{ -else }}
107    {{ -if item.readwrite }}
108    return {cpp_namespace}::{item.flag_name}();
109    {{ -else }}
110    {{ if allow_instrumentation }}
111    auto result =
112        {{ if item.is_fixed_read_only }}
113	    {package_macro}_{item.flag_macro}
114	{{ else }}
115	    {item.default_value}
116	{{ endif }};
117
118    struct stat buffer;
119    if (stat("/metadata/aconfig_test_missions/mission_1", &buffer) != 0) \{
120        return result;
121    }
122
123    auto package_map_file = aconfig_storage::get_mapped_file(
124        "{item.container}",
125        aconfig_storage::StorageFileType::package_map);
126    if (!package_map_file.ok()) \{
127        ALOGI("error: failed to get package map file: %s", package_map_file.error().c_str());
128        return result;
129    }
130
131    auto package_read_context = aconfig_storage::get_package_read_context(
132        **package_map_file, "{package}");
133    if (!package_read_context.ok()) \{
134        ALOGI("error: failed to get package read context: %s", package_map_file.error().c_str());
135        return result;
136    }
137
138    delete *package_map_file;
139
140    auto flag_val_map = aconfig_storage::get_mapped_file(
141        "{item.container}",
142        aconfig_storage::StorageFileType::flag_val);
143    if (!flag_val_map.ok()) \{
144        ALOGI("error: failed to get flag val map: %s", package_map_file.error().c_str());
145        return result;
146    }
147
148    auto value = aconfig_storage::get_boolean_flag_value(
149        **flag_val_map,
150        package_read_context->boolean_start_index + {item.flag_offset});
151    if (!value.ok()) \{
152        ALOGI("error: failed to get flag val: %s", package_map_file.error().c_str());
153        return result;
154    }
155
156    delete *flag_val_map;
157
158    if (*value != result) \{
159        ALOGI("error: new storage value '%d' does not match current value '%d'", *value, result);
160    } else \{
161        ALOGI("success: new storage value was '%d, legacy storage was '%d'", *value, result);
162    }
163
164    return result;
165    {{ else }}
166    {{ -if item.is_fixed_read_only }}
167    return {package_macro}_{item.flag_macro};
168    {{ -else }}
169    return {item.default_value};
170    {{ -endif }}
171    {{ -endif }}
172    {{ -endif }}
173    {{ -endif }}
174}
175
176{{ -if is_test_mode }}
177void set_{header}_{item.flag_name}(bool val) \{
178    {cpp_namespace}::{item.flag_name}(val);
179}
180{{ -endif }}
181{{ endfor }}
182
183{{ -if is_test_mode }}
184void {header}_reset_flags() \{
185     {cpp_namespace}::reset_flags();
186}
187{{ -endif }}
188
189
190