blob: cbb1e8f82838a51886da065d94f1572c8f2dfc2f [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2006-2007 The Android Open Source Project
3 *
Mark Salyzyn00adb862014-03-19 11:00:06 -07004 * 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08007 *
Mark Salyzyn00adb862014-03-19 11:00:06 -07008 * http://www.apache.org/licenses/LICENSE-2.0
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08009 *
Mark Salyzyn00adb862014-03-19 11:00:06 -070010 * 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080014 * limitations under the License.
15 */
16
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080017#define LOG_TAG "CursorWindow"
18
Mathias Agopian49d2b182012-02-27 18:11:20 -080019#include <androidfw/CursorWindow.h>
Jeff Brown0cde89f2011-10-10 14:50:10 -070020
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060021#include "android-base/logging.h"
Michael Hoisiee28dd9f2024-03-12 18:15:14 +000022#include "android-base/mapped_file.h"
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060023#include "cutils/ashmem.h"
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080024
Michael Hoisiee28dd9f2024-03-12 18:15:14 +000025using android::base::MappedFile;
26
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080027namespace android {
28
Jeff Sharkey539fdff2020-09-23 21:43:23 -060029/**
30 * By default windows are lightweight inline allocations of this size;
31 * they're only inflated to ashmem regions when more space is needed.
32 */
33static constexpr const size_t kInlineSize = 16384;
34
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060035static constexpr const size_t kSlotShift = 4;
36static constexpr const size_t kSlotSizeBytes = 1 << kSlotShift;
37
38CursorWindow::CursorWindow() {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080039}
40
Jeff Brown0cde89f2011-10-10 14:50:10 -070041CursorWindow::~CursorWindow() {
Jeff Sharkey539fdff2020-09-23 21:43:23 -060042 if (mAshmemFd != -1) {
Michael Hoisiee28dd9f2024-03-12 18:15:14 +000043 mMappedFile.reset();
Jeff Sharkey539fdff2020-09-23 21:43:23 -060044 ::close(mAshmemFd);
45 } else {
46 free(mData);
47 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080048}
49
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060050status_t CursorWindow::create(const String8 &name, size_t inflatedSize, CursorWindow **outWindow) {
51 *outWindow = nullptr;
Jeff Sharkey539fdff2020-09-23 21:43:23 -060052
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060053 CursorWindow* window = new CursorWindow();
54 if (!window) goto fail;
Jeff Sharkey539fdff2020-09-23 21:43:23 -060055
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060056 window->mName = name;
57 window->mSize = std::min(kInlineSize, inflatedSize);
58 window->mInflatedSize = inflatedSize;
59 window->mData = malloc(window->mSize);
60 if (!window->mData) goto fail;
61 window->mReadOnly = false;
62
63 window->clear();
64 window->updateSlotsData();
65
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060066 *outWindow = window;
67 return OK;
68
69fail:
70 LOG(ERROR) << "Failed create";
71fail_silent:
Jeff Sharkey539fdff2020-09-23 21:43:23 -060072 delete window;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060073 return UNKNOWN_ERROR;
Jeff Sharkey539fdff2020-09-23 21:43:23 -060074}
75
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060076status_t CursorWindow::maybeInflate() {
77 int ashmemFd = 0;
78 void* newData = nullptr;
Michael Hoisiee28dd9f2024-03-12 18:15:14 +000079 std::unique_ptr<MappedFile> mappedFile;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060080
81 // Bail early when we can't expand any further
82 if (mReadOnly || mSize == mInflatedSize) {
83 return INVALID_OPERATION;
84 }
Jeff Sharkey539fdff2020-09-23 21:43:23 -060085
Jeff Brown0cde89f2011-10-10 14:50:10 -070086 String8 ashmemName("CursorWindow: ");
Jeff Sharkey539fdff2020-09-23 21:43:23 -060087 ashmemName.append(mName);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080088
Tomasz Wasilczykd2a69832023-08-10 23:54:44 +000089 ashmemFd = ashmem_create_region(ashmemName.c_str(), mInflatedSize);
Jeff Brown0cde89f2011-10-10 14:50:10 -070090 if (ashmemFd < 0) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060091 PLOG(ERROR) << "Failed ashmem_create_region";
92 goto fail_silent;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080093 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -060094
95 if (ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE) < 0) {
96 PLOG(ERROR) << "Failed ashmem_set_prot_region";
97 goto fail_silent;
98 }
99
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000100 mappedFile = MappedFile::FromFd(ashmemFd, 0, mInflatedSize, PROT_READ | PROT_WRITE);
101 if (mappedFile == nullptr) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600102 PLOG(ERROR) << "Failed mmap";
103 goto fail_silent;
104 }
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000105 newData = mappedFile->data();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600106
107 if (ashmem_set_prot_region(ashmemFd, PROT_READ) < 0) {
108 PLOG(ERROR) << "Failed ashmem_set_prot_region";
109 goto fail_silent;
110 }
111
112 {
113 // Migrate existing contents into new ashmem region
Lee Shombertc7e15902023-05-19 15:52:00 -0700114 uint32_t slotsSize = sizeOfSlots();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600115 uint32_t newSlotsOffset = mInflatedSize - slotsSize;
116 memcpy(static_cast<uint8_t*>(newData),
117 static_cast<uint8_t*>(mData), mAllocOffset);
118 memcpy(static_cast<uint8_t*>(newData) + newSlotsOffset,
119 static_cast<uint8_t*>(mData) + mSlotsOffset, slotsSize);
120
121 free(mData);
122 mAshmemFd = ashmemFd;
123 mData = newData;
124 mSize = mInflatedSize;
125 mSlotsOffset = newSlotsOffset;
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000126 mMappedFile = std::move(mappedFile);
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600127
128 updateSlotsData();
129 }
130
131 LOG(DEBUG) << "Inflated: " << this->toString();
132 return OK;
133
134fail:
135 LOG(ERROR) << "Failed maybeInflate";
136fail_silent:
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000137 mappedFile.reset();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600138 ::close(ashmemFd);
139 return UNKNOWN_ERROR;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800140}
141
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600142status_t CursorWindow::createFromParcel(Parcel* parcel, CursorWindow** outWindow) {
143 *outWindow = nullptr;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700144
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600145 CursorWindow* window = new CursorWindow();
146 if (!window) goto fail;
147
148 if (parcel->readString8(&window->mName)) goto fail;
149 if (parcel->readUint32(&window->mNumRows)) goto fail;
150 if (parcel->readUint32(&window->mNumColumns)) goto fail;
151 if (parcel->readUint32(&window->mSize)) goto fail;
152
153 if ((window->mNumRows * window->mNumColumns * kSlotSizeBytes) > window->mSize) {
154 LOG(ERROR) << "Unexpected size " << window->mSize << " for " << window->mNumRows
155 << " rows and " << window->mNumColumns << " columns";
156 goto fail_silent;
157 }
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600158
159 bool isAshmem;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600160 if (parcel->readBool(&isAshmem)) goto fail;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600161 if (isAshmem) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600162 window->mAshmemFd = parcel->readFileDescriptor();
163 if (window->mAshmemFd < 0) {
164 LOG(ERROR) << "Failed readFileDescriptor";
165 goto fail_silent;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700166 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600167
168 window->mAshmemFd = ::fcntl(window->mAshmemFd, F_DUPFD_CLOEXEC, 0);
169 if (window->mAshmemFd < 0) {
170 PLOG(ERROR) << "Failed F_DUPFD_CLOEXEC";
171 goto fail_silent;
172 }
173
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000174 window->mMappedFile = MappedFile::FromFd(window->mAshmemFd, 0, window->mSize, PROT_READ);
175 if (window->mMappedFile == nullptr) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600176 PLOG(ERROR) << "Failed mmap";
177 goto fail_silent;
178 }
Michael Hoisiee28dd9f2024-03-12 18:15:14 +0000179 window->mData = window->mMappedFile->data();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600180 } else {
181 window->mAshmemFd = -1;
182
183 if (window->mSize > kInlineSize) {
184 LOG(ERROR) << "Unexpected size " << window->mSize << " for inline window";
185 goto fail_silent;
186 }
187
188 window->mData = malloc(window->mSize);
189 if (!window->mData) goto fail;
190
191 if (parcel->read(window->mData, window->mSize)) goto fail;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700192 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800193
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600194 // We just came from a remote source, so we're read-only
195 // and we can't inflate ourselves
196 window->mInflatedSize = window->mSize;
197 window->mReadOnly = true;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600198
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600199 window->updateSlotsData();
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600200
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600201 LOG(DEBUG) << "Created from parcel: " << window->toString();
202 *outWindow = window;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600203 return OK;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600204
205fail:
206 LOG(ERROR) << "Failed createFromParcel";
207fail_silent:
208 delete window;
209 return UNKNOWN_ERROR;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600210}
211
Jeff Brown0cde89f2011-10-10 14:50:10 -0700212status_t CursorWindow::writeToParcel(Parcel* parcel) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600213 LOG(DEBUG) << "Writing to parcel: " << this->toString();
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600214
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600215 if (parcel->writeString8(mName)) goto fail;
216 if (parcel->writeUint32(mNumRows)) goto fail;
217 if (parcel->writeUint32(mNumColumns)) goto fail;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600218 if (mAshmemFd != -1) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600219 if (parcel->writeUint32(mSize)) goto fail;
220 if (parcel->writeBool(true)) goto fail;
221 if (parcel->writeDupFileDescriptor(mAshmemFd)) goto fail;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600222 } else {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600223 // Since we know we're going to be read-only on the remote side,
Lee Shombertc7e15902023-05-19 15:52:00 -0700224 // we can compact ourselves on the wire.
225 size_t slotsSize = sizeOfSlots();
226 size_t compactedSize = sizeInUse();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600227 if (parcel->writeUint32(compactedSize)) goto fail;
228 if (parcel->writeBool(false)) goto fail;
229 void* dest = parcel->writeInplace(compactedSize);
230 if (!dest) goto fail;
231 memcpy(static_cast<uint8_t*>(dest),
232 static_cast<uint8_t*>(mData), mAllocOffset);
233 memcpy(static_cast<uint8_t*>(dest) + compactedSize - slotsSize,
234 static_cast<uint8_t*>(mData) + mSlotsOffset, slotsSize);
Jeff Brown0cde89f2011-10-10 14:50:10 -0700235 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600236 return OK;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600237
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600238fail:
239 LOG(ERROR) << "Failed writeToParcel";
240fail_silent:
241 return UNKNOWN_ERROR;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700242}
243
244status_t CursorWindow::clear() {
245 if (mReadOnly) {
246 return INVALID_OPERATION;
247 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600248 mAllocOffset = 0;
249 mSlotsOffset = mSize;
250 mNumRows = 0;
251 mNumColumns = 0;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700252 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800253}
254
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600255void CursorWindow::updateSlotsData() {
Jeff Sharkey256da5a2020-10-13 09:40:52 -0600256 mSlotsStart = static_cast<uint8_t*>(mData) + mSize - kSlotSizeBytes;
257 mSlotsEnd = static_cast<uint8_t*>(mData) + mSlotsOffset;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600258}
259
260void* CursorWindow::offsetToPtr(uint32_t offset, uint32_t bufferSize = 0) {
261 if (offset > mSize) {
262 LOG(ERROR) << "Offset " << offset
263 << " out of bounds, max value " << mSize;
264 return nullptr;
265 }
266 if (offset + bufferSize > mSize) {
267 LOG(ERROR) << "End offset " << (offset + bufferSize)
268 << " out of bounds, max value " << mSize;
269 return nullptr;
270 }
271 return static_cast<uint8_t*>(mData) + offset;
272}
273
274uint32_t CursorWindow::offsetFromPtr(void* ptr) {
275 return static_cast<uint8_t*>(ptr) - static_cast<uint8_t*>(mData);
276}
277
Jeff Brown0cde89f2011-10-10 14:50:10 -0700278status_t CursorWindow::setNumColumns(uint32_t numColumns) {
279 if (mReadOnly) {
280 return INVALID_OPERATION;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800281 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600282 uint32_t cur = mNumColumns;
283 if ((cur > 0 || mNumRows > 0) && cur != numColumns) {
284 LOG(ERROR) << "Trying to go from " << cur << " columns to " << numColumns;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700285 return INVALID_OPERATION;
286 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600287 mNumColumns = numColumns;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700288 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800289}
290
Jeff Brown0cde89f2011-10-10 14:50:10 -0700291status_t CursorWindow::allocRow() {
292 if (mReadOnly) {
293 return INVALID_OPERATION;
294 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600295 size_t size = mNumColumns * kSlotSizeBytes;
Jeff Sharkeyb2bbdaa2020-10-20 13:19:04 -0600296 int32_t newOffset = mSlotsOffset - size;
297 if (newOffset < (int32_t) mAllocOffset) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600298 maybeInflate();
299 newOffset = mSlotsOffset - size;
Jeff Sharkeyb2bbdaa2020-10-20 13:19:04 -0600300 if (newOffset < (int32_t) mAllocOffset) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600301 return NO_MEMORY;
302 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800303 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600304 memset(offsetToPtr(newOffset), 0, size);
305 mSlotsOffset = newOffset;
Jeff Sharkey256da5a2020-10-13 09:40:52 -0600306 updateSlotsData();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600307 mNumRows++;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700308 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800309}
310
Jeff Brown0cde89f2011-10-10 14:50:10 -0700311status_t CursorWindow::freeLastRow() {
312 if (mReadOnly) {
313 return INVALID_OPERATION;
314 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600315 size_t size = mNumColumns * kSlotSizeBytes;
Jeff Sharkeyb2bbdaa2020-10-20 13:19:04 -0600316 size_t newOffset = mSlotsOffset + size;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600317 if (newOffset > mSize) {
318 return NO_MEMORY;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700319 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600320 mSlotsOffset = newOffset;
Jeff Sharkey256da5a2020-10-13 09:40:52 -0600321 updateSlotsData();
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600322 mNumRows--;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700323 return OK;
324}
325
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600326status_t CursorWindow::alloc(size_t size, uint32_t* outOffset) {
327 if (mReadOnly) {
328 return INVALID_OPERATION;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800329 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600330 size_t alignedSize = (size + 3) & ~3;
Jeff Sharkeyb2bbdaa2020-10-20 13:19:04 -0600331 size_t newOffset = mAllocOffset + alignedSize;
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600332 if (newOffset > mSlotsOffset) {
333 maybeInflate();
334 newOffset = mAllocOffset + alignedSize;
335 if (newOffset > mSlotsOffset) {
336 return NO_MEMORY;
Jeff Sharkey539fdff2020-09-23 21:43:23 -0600337 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800338 }
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600339 *outOffset = mAllocOffset;
340 mAllocOffset = newOffset;
341 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800342}
343
Jeff Brown0cde89f2011-10-10 14:50:10 -0700344CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row, uint32_t column) {
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600345 // This is carefully tuned to use as few cycles as
346 // possible, since this is an extremely hot code path;
347 // see CursorWindow_bench.cpp for more details
Jeff Sharkey256da5a2020-10-13 09:40:52 -0600348 void *result = static_cast<uint8_t*>(mSlotsStart)
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600349 - (((row * mNumColumns) + column) << kSlotShift);
Jeff Sharkeyb2bbdaa2020-10-20 13:19:04 -0600350 if (result < mSlotsEnd || result > mSlotsStart || column >= mNumColumns) {
Jeff Sharkey256da5a2020-10-13 09:40:52 -0600351 LOG(ERROR) << "Failed to read row " << row << ", column " << column
352 << " from a window with " << mNumRows << " rows, " << mNumColumns << " columns";
353 return nullptr;
354 } else {
355 return static_cast<FieldSlot*>(result);
356 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800357}
358
Jeff Brown0cde89f2011-10-10 14:50:10 -0700359status_t CursorWindow::putBlob(uint32_t row, uint32_t column, const void* value, size_t size) {
360 return putBlobOrString(row, column, value, size, FIELD_TYPE_BLOB);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800361}
362
Jeff Brown0cde89f2011-10-10 14:50:10 -0700363status_t CursorWindow::putString(uint32_t row, uint32_t column, const char* value,
364 size_t sizeIncludingNull) {
365 return putBlobOrString(row, column, value, sizeIncludingNull, FIELD_TYPE_STRING);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800366}
367
Jeff Brown0cde89f2011-10-10 14:50:10 -0700368status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
369 const void* value, size_t size, int32_t type) {
370 if (mReadOnly) {
371 return INVALID_OPERATION;
372 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800373
Jeff Brown0cde89f2011-10-10 14:50:10 -0700374 FieldSlot* fieldSlot = getFieldSlot(row, column);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800375 if (!fieldSlot) {
Jeff Brown0cde89f2011-10-10 14:50:10 -0700376 return BAD_VALUE;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800377 }
378
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600379 uint32_t offset;
380 if (alloc(size, &offset)) {
Jeff Brown0cde89f2011-10-10 14:50:10 -0700381 return NO_MEMORY;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800382 }
383
Jeff Brown0cde89f2011-10-10 14:50:10 -0700384 memcpy(offsetToPtr(offset), value, size);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800385
Jeff Sharkeyae2d88a2020-09-26 18:57:32 -0600386 fieldSlot = getFieldSlot(row, column);
Jeff Brown0cde89f2011-10-10 14:50:10 -0700387 fieldSlot->type = type;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800388 fieldSlot->data.buffer.offset = offset;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700389 fieldSlot->data.buffer.size = size;
390 return OK;
391}
392
393status_t CursorWindow::putLong(uint32_t row, uint32_t column, int64_t value) {
394 if (mReadOnly) {
395 return INVALID_OPERATION;
396 }
397
398 FieldSlot* fieldSlot = getFieldSlot(row, column);
399 if (!fieldSlot) {
400 return BAD_VALUE;
401 }
402
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800403 fieldSlot->type = FIELD_TYPE_INTEGER;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700404 fieldSlot->data.l = value;
405 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800406}
407
Jeff Brown0cde89f2011-10-10 14:50:10 -0700408status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
409 if (mReadOnly) {
410 return INVALID_OPERATION;
411 }
412
413 FieldSlot* fieldSlot = getFieldSlot(row, column);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800414 if (!fieldSlot) {
Jeff Brown0cde89f2011-10-10 14:50:10 -0700415 return BAD_VALUE;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800416 }
417
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800418 fieldSlot->type = FIELD_TYPE_FLOAT;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700419 fieldSlot->data.d = value;
420 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800421}
422
Jeff Brown0cde89f2011-10-10 14:50:10 -0700423status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
424 if (mReadOnly) {
425 return INVALID_OPERATION;
426 }
427
428 FieldSlot* fieldSlot = getFieldSlot(row, column);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800429 if (!fieldSlot) {
Jeff Brown0cde89f2011-10-10 14:50:10 -0700430 return BAD_VALUE;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800431 }
432
433 fieldSlot->type = FIELD_TYPE_NULL;
434 fieldSlot->data.buffer.offset = 0;
435 fieldSlot->data.buffer.size = 0;
Jeff Brown0cde89f2011-10-10 14:50:10 -0700436 return OK;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800437}
438
439}; // namespace android