Merge "Make PersistableBundle getter functions const" into main

Treehugger Robot · Gerrit Code Review · commit 7b9adabb4afc · 2024-07-09T23:14:32.000Z
diff --git a/libs/binder/ndk/include_cpp/android/persistable_bundle_aidl.h b/libs/binder/ndk/include_cpp/android/persistable_bundle_aidl.h
@@ -271,31 +271,31 @@ class PersistableBundle {
         }
     }
 
-    bool getBoolean(const std::string& key, bool* _Nonnull val) {
+    bool getBoolean(const std::string& key, bool* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return APersistableBundle_getBoolean(mPBundle, key.c_str(), val);
         } else {
             return false;
         }
     }
 
-    bool getInt(const std::string& key, int32_t* _Nonnull val) {
+    bool getInt(const std::string& key, int32_t* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return APersistableBundle_getInt(mPBundle, key.c_str(), val);
         } else {
             return false;
         }
     }
 
-    bool getLong(const std::string& key, int64_t* _Nonnull val) {
+    bool getLong(const std::string& key, int64_t* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return APersistableBundle_getLong(mPBundle, key.c_str(), val);
         } else {
             return false;
         }
     }
 
-    bool getDouble(const std::string& key, double* _Nonnull val) {
+    bool getDouble(const std::string& key, double* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return APersistableBundle_getDouble(mPBundle, key.c_str(), val);
         } else {
@@ -307,7 +307,7 @@ class PersistableBundle {
         return (char*)malloc(bufferSizeBytes);
     }
 
-    bool getString(const std::string& key, std::string* _Nonnull val) {
+    bool getString(const std::string& key, std::string* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             char* outString = nullptr;
             bool ret = APersistableBundle_getString(mPBundle, key.c_str(), &outString,
@@ -325,7 +325,7 @@ class PersistableBundle {
     bool getVecInternal(int32_t (*_Nonnull getVec)(const APersistableBundle* _Nonnull,
                                                    const char* _Nonnull, T* _Nullable, int32_t),
                         const APersistableBundle* _Nonnull pBundle, const char* _Nonnull key,
-                        std::vector<T>* _Nonnull vec) {
+                        std::vector<T>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             int32_t bytes = 0;
             // call first with nullptr to get required size in bytes
@@ -347,28 +347,28 @@ class PersistableBundle {
         return false;
     }
 
-    bool getBooleanVector(const std::string& key, std::vector<bool>* _Nonnull vec) {
+    bool getBooleanVector(const std::string& key, std::vector<bool>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getVecInternal<bool>(&APersistableBundle_getBooleanVector, mPBundle, key.c_str(),
                                         vec);
         }
         return false;
     }
-    bool getIntVector(const std::string& key, std::vector<int32_t>* _Nonnull vec) {
+    bool getIntVector(const std::string& key, std::vector<int32_t>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getVecInternal<int32_t>(&APersistableBundle_getIntVector, mPBundle, key.c_str(),
                                            vec);
         }
         return false;
     }
-    bool getLongVector(const std::string& key, std::vector<int64_t>* _Nonnull vec) {
+    bool getLongVector(const std::string& key, std::vector<int64_t>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getVecInternal<int64_t>(&APersistableBundle_getLongVector, mPBundle, key.c_str(),
                                            vec);
         }
         return false;
     }
-    bool getDoubleVector(const std::string& key, std::vector<double>* _Nonnull vec) {
+    bool getDoubleVector(const std::string& key, std::vector<double>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getVecInternal<double>(&APersistableBundle_getDoubleVector, mPBundle,
                                           key.c_str(), vec);
@@ -379,7 +379,7 @@ class PersistableBundle {
     // Takes ownership of and frees the char** and its elements.
     // Creates a new set or vector based on the array of char*.
     template <typename T>
-    T moveStringsInternal(char* _Nullable* _Nonnull strings, int32_t bufferSizeBytes) {
+    T moveStringsInternal(char* _Nullable* _Nonnull strings, int32_t bufferSizeBytes) const {
         if (strings && bufferSizeBytes > 0) {
             int32_t num = bufferSizeBytes / sizeof(char*);
             T ret;
@@ -393,7 +393,7 @@ class PersistableBundle {
         return T();
     }
 
-    bool getStringVector(const std::string& key, std::vector<std::string>* _Nonnull vec) {
+    bool getStringVector(const std::string& key, std::vector<std::string>* _Nonnull vec) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             int32_t bytes = APersistableBundle_getStringVector(mPBundle, key.c_str(), nullptr, 0,
                                                                &stringAllocator, nullptr);
@@ -410,7 +410,7 @@ class PersistableBundle {
         return false;
     }
 
-    bool getPersistableBundle(const std::string& key, PersistableBundle* _Nonnull val) {
+    bool getPersistableBundle(const std::string& key, PersistableBundle* _Nonnull val) const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             APersistableBundle* bundle = nullptr;
             bool ret = APersistableBundle_getPersistableBundle(mPBundle, key.c_str(), &bundle);
@@ -429,7 +429,7 @@ class PersistableBundle {
                                              int32_t bufferSizeBytes,
                                              APersistableBundle_stringAllocator stringAllocator,
                                              void* _Nullable),
-            const APersistableBundle* _Nonnull pBundle) {
+            const APersistableBundle* _Nonnull pBundle) const {
         // call first with nullptr to get required size in bytes
         int32_t bytes = getTypedKeys(pBundle, nullptr, 0, &stringAllocator, nullptr);
         if (bytes > 0) {
@@ -442,84 +442,84 @@ class PersistableBundle {
         return {};
     }
 
-    std::set<std::string> getBooleanKeys() {
+    std::set<std::string> getBooleanKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getBooleanKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getIntKeys() {
+    std::set<std::string> getIntKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getIntKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getLongKeys() {
+    std::set<std::string> getLongKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getLongKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getDoubleKeys() {
+    std::set<std::string> getDoubleKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getDoubleKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getStringKeys() {
+    std::set<std::string> getStringKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getStringKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getBooleanVectorKeys() {
+    std::set<std::string> getBooleanVectorKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getBooleanVectorKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getIntVectorKeys() {
+    std::set<std::string> getIntVectorKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getIntVectorKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getLongVectorKeys() {
+    std::set<std::string> getLongVectorKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getLongVectorKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getDoubleVectorKeys() {
+    std::set<std::string> getDoubleVectorKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getDoubleVectorKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getStringVectorKeys() {
+    std::set<std::string> getStringVectorKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getStringVectorKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getPersistableBundleKeys() {
+    std::set<std::string> getPersistableBundleKeys() const {
         if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {
             return getKeys(&APersistableBundle_getPersistableBundleKeys, mPBundle);
         } else {
             return {};
         }
     }
-    std::set<std::string> getMonKeys() {
+    std::set<std::string> getMonKeys() const {
         // :P
         return {"c(o,o)b", "c(o,o)b"};
     }

Original file line number	Diff line number	Diff line change
`@@ -271,31 +271,31 @@ class PersistableBundle {`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`274`		`- bool getBoolean(const std::string& key, bool* _Nonnull val) {`
	`274`	`+ bool getBoolean(const std::string& key, bool* _Nonnull val) const {`
`275`	`275`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`276`	`276`	`return APersistableBundle_getBoolean(mPBundle, key.c_str(), val);`
`277`	`277`	`} else {`
`278`	`278`	`return false;`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`282`		`- bool getInt(const std::string& key, int32_t* _Nonnull val) {`
	`282`	`+ bool getInt(const std::string& key, int32_t* _Nonnull val) const {`
`283`	`283`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`284`	`284`	`return APersistableBundle_getInt(mPBundle, key.c_str(), val);`
`285`	`285`	`} else {`
`286`	`286`	`return false;`
`287`	`287`	`}`
`288`	`288`	`}`
`289`	`289`
`290`		`- bool getLong(const std::string& key, int64_t* _Nonnull val) {`
	`290`	`+ bool getLong(const std::string& key, int64_t* _Nonnull val) const {`
`291`	`291`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`292`	`292`	`return APersistableBundle_getLong(mPBundle, key.c_str(), val);`
`293`	`293`	`} else {`
`294`	`294`	`return false;`
`295`	`295`	`}`
`296`	`296`	`}`
`297`	`297`
`298`		`- bool getDouble(const std::string& key, double* _Nonnull val) {`
	`298`	`+ bool getDouble(const std::string& key, double* _Nonnull val) const {`
`299`	`299`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`300`	`300`	`return APersistableBundle_getDouble(mPBundle, key.c_str(), val);`
`301`	`301`	`} else {`
`@@ -307,7 +307,7 @@ class PersistableBundle {`
`307`	`307`	`return (char*)malloc(bufferSizeBytes);`
`308`	`308`	`}`
`309`	`309`
`310`		`- bool getString(const std::string& key, std::string* _Nonnull val) {`
	`310`	`+ bool getString(const std::string& key, std::string* _Nonnull val) const {`
`311`	`311`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`312`	`312`	`char* outString = nullptr;`
`313`	`313`	`bool ret = APersistableBundle_getString(mPBundle, key.c_str(), &outString,`
`@@ -325,7 +325,7 @@ class PersistableBundle {`
`325`	`325`	`bool getVecInternal(int32_t (_Nonnull getVec)(const APersistableBundle _Nonnull,`
`326`	`326`	`const char* _Nonnull, T* _Nullable, int32_t),`
`327`	`327`	`const APersistableBundle* _Nonnull pBundle, const char* _Nonnull key,`
`328`		`- std::vector<T>* _Nonnull vec) {`
	`328`	`+ std::vector<T>* _Nonnull vec) const {`
`329`	`329`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`330`	`330`	`int32_t bytes = 0;`
`331`	`331`	`// call first with nullptr to get required size in bytes`
`@@ -347,28 +347,28 @@ class PersistableBundle {`
`347`	`347`	`return false;`
`348`	`348`	`}`
`349`	`349`
`350`		`- bool getBooleanVector(const std::string& key, std::vector<bool>* _Nonnull vec) {`
	`350`	`+ bool getBooleanVector(const std::string& key, std::vector<bool>* _Nonnull vec) const {`
`351`	`351`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`352`	`352`	`return getVecInternal<bool>(&APersistableBundle_getBooleanVector, mPBundle, key.c_str(),`
`353`	`353`	`vec);`
`354`	`354`	`}`
`355`	`355`	`return false;`
`356`	`356`	`}`
`357`		`- bool getIntVector(const std::string& key, std::vector<int32_t>* _Nonnull vec) {`
	`357`	`+ bool getIntVector(const std::string& key, std::vector<int32_t>* _Nonnull vec) const {`
`358`	`358`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`359`	`359`	`return getVecInternal<int32_t>(&APersistableBundle_getIntVector, mPBundle, key.c_str(),`
`360`	`360`	`vec);`
`361`	`361`	`}`
`362`	`362`	`return false;`
`363`	`363`	`}`
`364`		`- bool getLongVector(const std::string& key, std::vector<int64_t>* _Nonnull vec) {`
	`364`	`+ bool getLongVector(const std::string& key, std::vector<int64_t>* _Nonnull vec) const {`
`365`	`365`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`366`	`366`	`return getVecInternal<int64_t>(&APersistableBundle_getLongVector, mPBundle, key.c_str(),`
`367`	`367`	`vec);`
`368`	`368`	`}`
`369`	`369`	`return false;`
`370`	`370`	`}`
`371`		`- bool getDoubleVector(const std::string& key, std::vector<double>* _Nonnull vec) {`
	`371`	`+ bool getDoubleVector(const std::string& key, std::vector<double>* _Nonnull vec) const {`
`372`	`372`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`373`	`373`	`return getVecInternal<double>(&APersistableBundle_getDoubleVector, mPBundle,`
`374`	`374`	`key.c_str(), vec);`
`@@ -379,7 +379,7 @@ class PersistableBundle {`
`379`	`379`	`// Takes ownership of and frees the char** and its elements.`
`380`	`380`	`// Creates a new set or vector based on the array of char*.`
`381`	`381`	`template <typename T>`
`382`		`- T moveStringsInternal(char* _Nullable* _Nonnull strings, int32_t bufferSizeBytes) {`
	`382`	`+ T moveStringsInternal(char* _Nullable* _Nonnull strings, int32_t bufferSizeBytes) const {`
`383`	`383`	`if (strings && bufferSizeBytes > 0) {`
`384`	`384`	`int32_t num = bufferSizeBytes / sizeof(char*);`
`385`	`385`	`T ret;`
`@@ -393,7 +393,7 @@ class PersistableBundle {`
`393`	`393`	`return T();`
`394`	`394`	`}`
`395`	`395`
`396`		`- bool getStringVector(const std::string& key, std::vector<std::string>* _Nonnull vec) {`
	`396`	`+ bool getStringVector(const std::string& key, std::vector<std::string>* _Nonnull vec) const {`
`397`	`397`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`398`	`398`	`int32_t bytes = APersistableBundle_getStringVector(mPBundle, key.c_str(), nullptr, 0,`
`399`	`399`	`&stringAllocator, nullptr);`
`@@ -410,7 +410,7 @@ class PersistableBundle {`
`410`	`410`	`return false;`
`411`	`411`	`}`
`412`	`412`
`413`		`- bool getPersistableBundle(const std::string& key, PersistableBundle* _Nonnull val) {`
	`413`	`+ bool getPersistableBundle(const std::string& key, PersistableBundle* _Nonnull val) const {`
`414`	`414`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`415`	`415`	`APersistableBundle* bundle = nullptr;`
`416`	`416`	`bool ret = APersistableBundle_getPersistableBundle(mPBundle, key.c_str(), &bundle);`
`@@ -429,7 +429,7 @@ class PersistableBundle {`
`429`	`429`	`int32_t bufferSizeBytes,`
`430`	`430`	`APersistableBundle_stringAllocator stringAllocator,`
`431`	`431`	`void* _Nullable),`
`432`		`- const APersistableBundle* _Nonnull pBundle) {`
	`432`	`+ const APersistableBundle* _Nonnull pBundle) const {`
`433`	`433`	`// call first with nullptr to get required size in bytes`
`434`	`434`	`int32_t bytes = getTypedKeys(pBundle, nullptr, 0, &stringAllocator, nullptr);`
`435`	`435`	`if (bytes > 0) {`
`@@ -442,84 +442,84 @@ class PersistableBundle {`
`442`	`442`	`return {};`
`443`	`443`	`}`
`444`	`444`
`445`		`- std::set<std::string> getBooleanKeys() {`
	`445`	`+ std::set<std::string> getBooleanKeys() const {`
`446`	`446`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`447`	`447`	`return getKeys(&APersistableBundle_getBooleanKeys, mPBundle);`
`448`	`448`	`} else {`
`449`	`449`	`return {};`
`450`	`450`	`}`
`451`	`451`	`}`
`452`		`- std::set<std::string> getIntKeys() {`
	`452`	`+ std::set<std::string> getIntKeys() const {`
`453`	`453`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`454`	`454`	`return getKeys(&APersistableBundle_getIntKeys, mPBundle);`
`455`	`455`	`} else {`
`456`	`456`	`return {};`
`457`	`457`	`}`
`458`	`458`	`}`
`459`		`- std::set<std::string> getLongKeys() {`
	`459`	`+ std::set<std::string> getLongKeys() const {`
`460`	`460`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`461`	`461`	`return getKeys(&APersistableBundle_getLongKeys, mPBundle);`
`462`	`462`	`} else {`
`463`	`463`	`return {};`
`464`	`464`	`}`
`465`	`465`	`}`
`466`		`- std::set<std::string> getDoubleKeys() {`
	`466`	`+ std::set<std::string> getDoubleKeys() const {`
`467`	`467`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`468`	`468`	`return getKeys(&APersistableBundle_getDoubleKeys, mPBundle);`
`469`	`469`	`} else {`
`470`	`470`	`return {};`
`471`	`471`	`}`
`472`	`472`	`}`
`473`		`- std::set<std::string> getStringKeys() {`
	`473`	`+ std::set<std::string> getStringKeys() const {`
`474`	`474`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`475`	`475`	`return getKeys(&APersistableBundle_getStringKeys, mPBundle);`
`476`	`476`	`} else {`
`477`	`477`	`return {};`
`478`	`478`	`}`
`479`	`479`	`}`
`480`		`- std::set<std::string> getBooleanVectorKeys() {`
	`480`	`+ std::set<std::string> getBooleanVectorKeys() const {`
`481`	`481`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`482`	`482`	`return getKeys(&APersistableBundle_getBooleanVectorKeys, mPBundle);`
`483`	`483`	`} else {`
`484`	`484`	`return {};`
`485`	`485`	`}`
`486`	`486`	`}`
`487`		`- std::set<std::string> getIntVectorKeys() {`
	`487`	`+ std::set<std::string> getIntVectorKeys() const {`
`488`	`488`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`489`	`489`	`return getKeys(&APersistableBundle_getIntVectorKeys, mPBundle);`
`490`	`490`	`} else {`
`491`	`491`	`return {};`
`492`	`492`	`}`
`493`	`493`	`}`
`494`		`- std::set<std::string> getLongVectorKeys() {`
	`494`	`+ std::set<std::string> getLongVectorKeys() const {`
`495`	`495`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`496`	`496`	`return getKeys(&APersistableBundle_getLongVectorKeys, mPBundle);`
`497`	`497`	`} else {`
`498`	`498`	`return {};`
`499`	`499`	`}`
`500`	`500`	`}`
`501`		`- std::set<std::string> getDoubleVectorKeys() {`
	`501`	`+ std::set<std::string> getDoubleVectorKeys() const {`
`502`	`502`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`503`	`503`	`return getKeys(&APersistableBundle_getDoubleVectorKeys, mPBundle);`
`504`	`504`	`} else {`
`505`	`505`	`return {};`
`506`	`506`	`}`
`507`	`507`	`}`
`508`		`- std::set<std::string> getStringVectorKeys() {`
	`508`	`+ std::set<std::string> getStringVectorKeys() const {`
`509`	`509`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`510`	`510`	`return getKeys(&APersistableBundle_getStringVectorKeys, mPBundle);`
`511`	`511`	`} else {`
`512`	`512`	`return {};`
`513`	`513`	`}`
`514`	`514`	`}`
`515`		`- std::set<std::string> getPersistableBundleKeys() {`
	`515`	`+ std::set<std::string> getPersistableBundleKeys() const {`
`516`	`516`	`if API_LEVEL_AT_LEAST(__ANDROID_API_V__, 202404) {`
`517`	`517`	`return getKeys(&APersistableBundle_getPersistableBundleKeys, mPBundle);`
`518`	`518`	`} else {`
`519`	`519`	`return {};`
`520`	`520`	`}`
`521`	`521`	`}`
`522`		`- std::set<std::string> getMonKeys() {`
	`522`	`+ std::set<std::string> getMonKeys() const {`
`523`	`523`	`// :P`
`524`	`524`	`return {"c(o,o)b", "c(o,o)b"};`
`525`	`525`	`}`