Status.cpp revision 1651ced6a84b3ba5b62917e88b981e6bac3e7e3f 
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#include <binder/Status.h>
18
19namespace android {
20namespace binder {
21
22Status Status::ok() {
23    return Status();
24}
25
26Status Status::fromExceptionCode(int32_t exceptionCode) {
27    return Status(exceptionCode, OK);
28}
29
30Status Status::fromExceptionCode(int32_t exceptionCode,
31                                 const String8& message) {
32    return Status(exceptionCode, OK, message);
33}
34
35Status Status::fromExceptionCode(int32_t exceptionCode,
36                                 const char* message) {
37    return fromExceptionCode(exceptionCode, String8(message));
38}
39
40Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode) {
41    return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode);
42}
43
44Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode,
45                                        const String8& message) {
46    return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode, message);
47}
48
49Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode,
50                                        const char* message) {
51    return fromServiceSpecificError(serviceSpecificErrorCode, String8(message));
52}
53
54Status Status::fromStatusT(status_t status) {
55    Status ret;
56    ret.setFromStatusT(status);
57    return ret;
58}
59
60Status::Status(int32_t exceptionCode, int32_t errorCode)
61    : mException(exceptionCode),
62      mErrorCode(errorCode) {}
63
64Status::Status(int32_t exceptionCode, int32_t errorCode, const String8& message)
65    : mException(exceptionCode),
66      mErrorCode(errorCode),
67      mMessage(message) {}
68
69status_t Status::readFromParcel(const Parcel& parcel) {
70    status_t status = parcel.readInt32(&mException);
71    if (status != OK) {
72        setFromStatusT(status);
73        return status;
74    }
75
76    // Skip over fat response headers.  Not used (or propagated) in native code.
77    if (mException == EX_HAS_REPLY_HEADER) {
78        // Note that the header size includes the 4 byte size field.
79        const int32_t header_start = parcel.dataPosition();
80        int32_t header_size;
81        status = parcel.readInt32(&header_size);
82        if (status != OK) {
83            setFromStatusT(status);
84            return status;
85        }
86        parcel.setDataPosition(header_start + header_size);
87        // And fat response headers are currently only used when there are no
88        // exceptions, so act like there was no error.
89        mException = EX_NONE;
90    }
91
92    if (mException == EX_NONE) {
93        return status;
94    }
95
96    // The remote threw an exception.  Get the message back.
97    String16 message;
98    status = parcel.readString16(&message);
99    if (status != OK) {
100        setFromStatusT(status);
101        return status;
102    }
103    mMessage = String8(message);
104
105    if (mException == EX_SERVICE_SPECIFIC) {
106        status = parcel.readInt32(&mErrorCode);
107    }
108    if (status != OK) {
109        setFromStatusT(status);
110        return status;
111    }
112
113    return status;
114}
115
116status_t Status::writeToParcel(Parcel* parcel) const {
117    // Something really bad has happened, and we're not going to even
118    // try returning rich error data.
119    if (mException == EX_TRANSACTION_FAILED) {
120        return mErrorCode;
121    }
122
123    status_t status = parcel->writeInt32(mException);
124    if (status != OK) { return status; }
125    if (mException == EX_NONE) {
126        // We have no more information to write.
127        return status;
128    }
129    status = parcel->writeString16(String16(mMessage));
130    if (mException != EX_SERVICE_SPECIFIC) {
131        // We have no more information to write.
132        return status;
133    }
134    status = parcel->writeInt32(mErrorCode);
135    return status;
136}
137
138void Status::setException(int32_t ex, const String8& message) {
139    mException = ex;
140    mErrorCode = NO_ERROR;  // an exception, not a transaction failure.
141    mMessage.setTo(message);
142}
143
144void Status::setServiceSpecificError(int32_t errorCode, const String8& message) {
145    setException(EX_SERVICE_SPECIFIC, message);
146    mErrorCode = errorCode;
147}
148
149void Status::setFromStatusT(status_t status) {
150    mException = (status == NO_ERROR) ? EX_NONE : EX_TRANSACTION_FAILED;
151    mErrorCode = status;
152    mMessage.clear();
153}
154
155String8 Status::toString8() const {
156    String8 ret;
157    if (mException == EX_NONE) {
158        ret.append("No error");
159    } else {
160        ret.appendFormat("Status(%d): '", mException);
161        if (mException == EX_SERVICE_SPECIFIC ||
162            mException == EX_TRANSACTION_FAILED) {
163            ret.appendFormat("%d: ", mErrorCode);
164        }
165        ret.append(String8(mMessage));
166        ret.append("'");
167    }
168    return ret;
169}
170
171std::stringstream& operator<< (std::stringstream& stream, const Status& s) {
172    stream << s.toString8().string();
173    return stream;
174}
175
176}  // namespace binder
177}  // namespace android
178