1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "Value"
18
19 #include <binder/Value.h>
20
21 #include <limits>
22
23 #include <binder/IBinder.h>
24 #include <binder/Parcel.h>
25 #include <binder/Map.h>
26 #include <private/binder/ParcelValTypes.h>
27 #include <log/log.h>
28 #include <utils/Errors.h>
29
30 using android::BAD_TYPE;
31 using android::BAD_VALUE;
32 using android::NO_ERROR;
33 using android::UNEXPECTED_NULL;
34 using android::Parcel;
35 using android::sp;
36 using android::status_t;
37 using std::map;
38 using std::set;
39 using std::vector;
40 using android::binder::Value;
41 using android::IBinder;
42 using android::os::PersistableBundle;
43 using namespace android::binder;
44
45 // ====================================================================
46
47 #define RETURN_IF_FAILED(calledOnce) \
48 do { \
49 status_t returnStatus = calledOnce; \
50 if (returnStatus) { \
51 ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \
52 return returnStatus; \
53 } \
54 } while(false)
55
56 // ====================================================================
57
58 /* These `internal_type_ptr()` functions allow this
59 * class to work without C++ RTTI support. This technique
60 * only works properly when called directly from this file,
61 * but that is OK because that is the only place we will
62 * be calling them from. */
internal_type_ptr()63 template<class T> const void* internal_type_ptr()
64 {
65 static const T *marker;
66 return (void*)▮
67 }
68
69 /* Allows the type to be specified by the argument
70 * instead of inside angle brackets. */
internal_type_ptr(const T &)71 template<class T> const void* internal_type_ptr(const T&)
72 {
73 return internal_type_ptr<T>();
74 }
75
76 // ====================================================================
77
78 namespace android {
79
80 namespace binder {
81
82 class Value::ContentBase {
83 public:
84 virtual ~ContentBase() = default;
85 virtual const void* type_ptr() const = 0;
86 virtual ContentBase * clone() const = 0;
87 virtual bool operator==(const ContentBase& rhs) const = 0;
88
89 #ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
90 virtual const std::type_info &type() const = 0;
91 #endif
92
93 template<typename T> bool get(T* out) const;
94 };
95
96 /* This is the actual class that holds the value. */
97 template<typename T> class Value::Content : public Value::ContentBase {
98 public:
99 Content() = default;
Content(const T & value)100 Content(const T & value) : mValue(value) { }
101
102 virtual ~Content() = default;
103
104 #ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
type() const105 virtual const std::type_info &type() const override
106 {
107 return typeid(T);
108 }
109 #endif
110
type_ptr() const111 virtual const void* type_ptr() const override
112 {
113 return internal_type_ptr<T>();
114 }
115
clone() const116 virtual ContentBase * clone() const override
117 {
118 return new Content(mValue);
119 };
120
operator ==(const ContentBase & rhs) const121 virtual bool operator==(const ContentBase& rhs) const override
122 {
123 if (type_ptr() != rhs.type_ptr()) {
124 return false;
125 }
126 return mValue == static_cast<const Content<T>* >(&rhs)->mValue;
127 }
128
129 T mValue;
130 };
131
get(T * out) const132 template<typename T> bool Value::ContentBase::get(T* out) const
133 {
134 if (internal_type_ptr(*out) != type_ptr())
135 {
136 return false;
137 }
138
139 *out = static_cast<const Content<T>*>(this)->mValue;
140
141 return true;
142 }
143
144 // ====================================================================
145
Value()146 Value::Value() : mContent(NULL)
147 {
148 }
149
Value(const Value & value)150 Value::Value(const Value& value)
151 : mContent(value.mContent ? value.mContent->clone() : NULL)
152 {
153 }
154
~Value()155 Value::~Value()
156 {
157 delete mContent;
158 }
159
operator ==(const Value & rhs) const160 bool Value::operator==(const Value& rhs) const
161 {
162 const Value& lhs(*this);
163
164 if (lhs.empty() && rhs.empty()) {
165 return true;
166 }
167
168 if ( (lhs.mContent == NULL)
169 || (rhs.mContent == NULL)
170 ) {
171 return false;
172 }
173
174 return *lhs.mContent == *rhs.mContent;
175 }
176
swap(Value & rhs)177 Value& Value::swap(Value &rhs)
178 {
179 std::swap(mContent, rhs.mContent);
180 return *this;
181 }
182
operator =(const Value & rhs)183 Value& Value::operator=(const Value& rhs)
184 {
185 delete mContent;
186 mContent = rhs.mContent
187 ? rhs.mContent->clone()
188 : NULL;
189 return *this;
190 }
191
empty() const192 bool Value::empty() const
193 {
194 return mContent == NULL;
195 }
196
clear()197 void Value::clear()
198 {
199 delete mContent;
200 mContent = NULL;
201 }
202
parcelType() const203 int32_t Value::parcelType() const
204 {
205 const void* t_info(mContent ? mContent->type_ptr() : NULL);
206
207 if (t_info == internal_type_ptr<bool>()) return VAL_BOOLEAN;
208 if (t_info == internal_type_ptr<uint8_t>()) return VAL_BYTE;
209 if (t_info == internal_type_ptr<int32_t>()) return VAL_INTEGER;
210 if (t_info == internal_type_ptr<int64_t>()) return VAL_LONG;
211 if (t_info == internal_type_ptr<double>()) return VAL_DOUBLE;
212 if (t_info == internal_type_ptr<String16>()) return VAL_STRING;
213
214 if (t_info == internal_type_ptr<vector<bool>>()) return VAL_BOOLEANARRAY;
215 if (t_info == internal_type_ptr<vector<uint8_t>>()) return VAL_BYTEARRAY;
216 if (t_info == internal_type_ptr<vector<int32_t>>()) return VAL_INTARRAY;
217 if (t_info == internal_type_ptr<vector<int64_t>>()) return VAL_LONGARRAY;
218 if (t_info == internal_type_ptr<vector<double>>()) return VAL_DOUBLEARRAY;
219 if (t_info == internal_type_ptr<vector<String16>>()) return VAL_STRINGARRAY;
220
221 if (t_info == internal_type_ptr<Map>()) return VAL_MAP;
222 if (t_info == internal_type_ptr<PersistableBundle>()) return VAL_PERSISTABLEBUNDLE;
223
224 return VAL_NULL;
225 }
226
227 #ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
type() const228 const std::type_info& Value::type() const
229 {
230 return mContent != NULL
231 ? mContent->type()
232 : typeid(void);
233 }
234 #endif // ifdef LIBBINDER_VALUE_SUPPORTS_TYPE_INFO
235
236 #define DEF_TYPE_ACCESSORS(T, TYPENAME) \
237 bool Value::is ## TYPENAME() const \
238 { \
239 return mContent \
240 ? internal_type_ptr<T>() == mContent->type_ptr() \
241 : false; \
242 } \
243 bool Value::get ## TYPENAME(T* out) const \
244 { \
245 return mContent \
246 ? mContent->get(out) \
247 : false; \
248 } \
249 void Value::put ## TYPENAME(const T& in) \
250 { \
251 *this = in; \
252 } \
253 Value& Value::operator=(const T& rhs) \
254 { \
255 delete mContent; \
256 mContent = new Content< T >(rhs); \
257 return *this; \
258 } \
259 Value::Value(const T& value) \
260 : mContent(new Content< T >(value)) \
261 { }
262
DEF_TYPE_ACCESSORS(bool,Boolean)263 DEF_TYPE_ACCESSORS(bool, Boolean)
264 DEF_TYPE_ACCESSORS(int8_t, Byte)
265 DEF_TYPE_ACCESSORS(int32_t, Int)
266 DEF_TYPE_ACCESSORS(int64_t, Long)
267 DEF_TYPE_ACCESSORS(double, Double)
268 DEF_TYPE_ACCESSORS(String16, String)
269
270 DEF_TYPE_ACCESSORS(std::vector<bool>, BooleanVector)
271 DEF_TYPE_ACCESSORS(std::vector<uint8_t>, ByteVector)
272 DEF_TYPE_ACCESSORS(std::vector<int32_t>, IntVector)
273 DEF_TYPE_ACCESSORS(std::vector<int64_t>, LongVector)
274 DEF_TYPE_ACCESSORS(std::vector<double>, DoubleVector)
275 DEF_TYPE_ACCESSORS(std::vector<String16>, StringVector)
276
277 DEF_TYPE_ACCESSORS(::android::binder::Map, Map)
278 DEF_TYPE_ACCESSORS(PersistableBundle, PersistableBundle)
279
280 bool Value::getString(String8* out) const
281 {
282 String16 val;
283 bool ret = getString(&val);
284 if (ret) {
285 *out = String8(val);
286 }
287 return ret;
288 }
289
getString(::std::string * out) const290 bool Value::getString(::std::string* out) const
291 {
292 String8 val;
293 bool ret = getString(&val);
294 if (ret) {
295 *out = val.string();
296 }
297 return ret;
298 }
299
writeToParcel(Parcel * parcel) const300 status_t Value::writeToParcel(Parcel* parcel) const
301 {
302 // This implementation needs to be kept in sync with the writeValue
303 // implementation in frameworks/base/core/java/android/os/Parcel.java
304
305 #define BEGIN_HANDLE_WRITE() \
306 do { \
307 const void* t_info(mContent?mContent->type_ptr():NULL); \
308 if (false) { }
309 #define HANDLE_WRITE_TYPE(T, TYPEVAL, TYPEMETHOD) \
310 else if (t_info == internal_type_ptr<T>()) { \
311 RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \
312 RETURN_IF_FAILED(parcel->TYPEMETHOD(static_cast<const Content<T>*>(mContent)->mValue)); \
313 }
314 #define HANDLE_WRITE_PARCELABLE(T, TYPEVAL) \
315 else if (t_info == internal_type_ptr<T>()) { \
316 RETURN_IF_FAILED(parcel->writeInt32(TYPEVAL)); \
317 RETURN_IF_FAILED(static_cast<const Content<T>*>(mContent)->mValue.writeToParcel(parcel)); \
318 }
319 #define END_HANDLE_WRITE() \
320 else { \
321 ALOGE("writeToParcel: Type not supported"); \
322 return BAD_TYPE; \
323 } \
324 } while (false);
325
326 BEGIN_HANDLE_WRITE()
327
328 HANDLE_WRITE_TYPE(bool, VAL_BOOLEAN, writeBool)
329 HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte)
330 HANDLE_WRITE_TYPE(int8_t, VAL_BYTE, writeByte)
331 HANDLE_WRITE_TYPE(int32_t, VAL_INTEGER, writeInt32)
332 HANDLE_WRITE_TYPE(int64_t, VAL_LONG, writeInt64)
333 HANDLE_WRITE_TYPE(double, VAL_DOUBLE, writeDouble)
334 HANDLE_WRITE_TYPE(String16, VAL_STRING, writeString16)
335
336 HANDLE_WRITE_TYPE(vector<bool>, VAL_BOOLEANARRAY, writeBoolVector)
337 HANDLE_WRITE_TYPE(vector<uint8_t>, VAL_BYTEARRAY, writeByteVector)
338 HANDLE_WRITE_TYPE(vector<int8_t>, VAL_BYTEARRAY, writeByteVector)
339 HANDLE_WRITE_TYPE(vector<int32_t>, VAL_INTARRAY, writeInt32Vector)
340 HANDLE_WRITE_TYPE(vector<int64_t>, VAL_LONGARRAY, writeInt64Vector)
341 HANDLE_WRITE_TYPE(vector<double>, VAL_DOUBLEARRAY, writeDoubleVector)
342 HANDLE_WRITE_TYPE(vector<String16>, VAL_STRINGARRAY, writeString16Vector)
343
344 HANDLE_WRITE_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE)
345
346 END_HANDLE_WRITE()
347
348 return NO_ERROR;
349
350 #undef BEGIN_HANDLE_WRITE
351 #undef HANDLE_WRITE_TYPE
352 #undef HANDLE_WRITE_PARCELABLE
353 #undef END_HANDLE_WRITE
354 }
355
readFromParcel(const Parcel * parcel)356 status_t Value::readFromParcel(const Parcel* parcel)
357 {
358 // This implementation needs to be kept in sync with the readValue
359 // implementation in frameworks/base/core/java/android/os/Parcel.javai
360
361 #define BEGIN_HANDLE_READ() \
362 switch(value_type) { \
363 default: \
364 ALOGE("readFromParcel: Parcel type %d is not supported", value_type); \
365 return BAD_TYPE;
366 #define HANDLE_READ_TYPE(T, TYPEVAL, TYPEMETHOD) \
367 case TYPEVAL: \
368 mContent = new Content<T>(); \
369 RETURN_IF_FAILED(parcel->TYPEMETHOD(&static_cast<Content<T>*>(mContent)->mValue)); \
370 break;
371 #define HANDLE_READ_PARCELABLE(T, TYPEVAL) \
372 case TYPEVAL: \
373 mContent = new Content<T>(); \
374 RETURN_IF_FAILED(static_cast<Content<T>*>(mContent)->mValue.readFromParcel(parcel)); \
375 break;
376 #define END_HANDLE_READ() \
377 }
378
379 int32_t value_type = VAL_NULL;
380
381 delete mContent;
382 mContent = NULL;
383
384 RETURN_IF_FAILED(parcel->readInt32(&value_type));
385
386 BEGIN_HANDLE_READ()
387
388 HANDLE_READ_TYPE(bool, VAL_BOOLEAN, readBool)
389 HANDLE_READ_TYPE(int8_t, VAL_BYTE, readByte)
390 HANDLE_READ_TYPE(int32_t, VAL_INTEGER, readInt32)
391 HANDLE_READ_TYPE(int64_t, VAL_LONG, readInt64)
392 HANDLE_READ_TYPE(double, VAL_DOUBLE, readDouble)
393 HANDLE_READ_TYPE(String16, VAL_STRING, readString16)
394
395 HANDLE_READ_TYPE(vector<bool>, VAL_BOOLEANARRAY, readBoolVector)
396 HANDLE_READ_TYPE(vector<uint8_t>, VAL_BYTEARRAY, readByteVector)
397 HANDLE_READ_TYPE(vector<int32_t>, VAL_INTARRAY, readInt32Vector)
398 HANDLE_READ_TYPE(vector<int64_t>, VAL_LONGARRAY, readInt64Vector)
399 HANDLE_READ_TYPE(vector<double>, VAL_DOUBLEARRAY, readDoubleVector)
400 HANDLE_READ_TYPE(vector<String16>, VAL_STRINGARRAY, readString16Vector)
401
402 HANDLE_READ_PARCELABLE(PersistableBundle, VAL_PERSISTABLEBUNDLE)
403
404 END_HANDLE_READ()
405
406 return NO_ERROR;
407
408 #undef BEGIN_HANDLE_READ
409 #undef HANDLE_READ_TYPE
410 #undef HANDLE_READ_PARCELABLE
411 #undef END_HANDLE_READ
412 }
413
414 } // namespace binder
415
416 } // namespace android
417
418 /* vim: set ts=4 sw=4 tw=0 et :*/
419