Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 1 | /* |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 2 | * Copyright 2021 The Android Open Source Project |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 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 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 17 | //#define LOG_NDEBUG 0 |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 18 | #define LOG_TAG "DvrClient" |
| 19 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 20 | #include "DvrClient.h" |
| 21 | |
| 22 | #include <aidl/android/hardware/tv/tuner/DemuxQueueNotifyBits.h> |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 23 | #include <android-base/logging.h> |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 24 | #include <inttypes.h> |
Hongguang | 90dd674 | 2021-11-23 13:24:00 -0800 | [diff] [blame] | 25 | #include <sys/types.h> |
| 26 | #include <unistd.h> |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 27 | #include <utils/Log.h> |
| 28 | |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 29 | #include "ClientHelper.h" |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 30 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 31 | using ::aidl::android::hardware::tv::tuner::DemuxQueueNotifyBits; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 32 | |
| 33 | namespace android { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 34 | /////////////// DvrClient /////////////////////// |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 35 | DvrClient::DvrClient(shared_ptr<ITunerDvr> tunerDvr) { |
| 36 | mTunerDvr = tunerDvr; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 37 | mFd = -1; |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 38 | mDvrMQ = nullptr; |
| 39 | mDvrMQEventFlag = nullptr; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 40 | } |
| 41 | |
| 42 | DvrClient::~DvrClient() { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 43 | mTunerDvr = nullptr; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 44 | mFd = -1; |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 45 | mDvrMQ = nullptr; |
| 46 | mDvrMQEventFlag = nullptr; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 47 | } |
| 48 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 49 | void DvrClient::setFd(int32_t fd) { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 50 | mFd = fd; |
| 51 | } |
| 52 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 53 | int64_t DvrClient::readFromFile(int64_t size) { |
| 54 | if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 55 | ALOGE("Failed to readFromFile. DVR mq is not configured"); |
| 56 | return -1; |
| 57 | } |
| 58 | if (mFd < 0) { |
| 59 | ALOGE("Failed to readFromFile. File is not configured"); |
| 60 | return -1; |
| 61 | } |
| 62 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 63 | int64_t available = mDvrMQ->availableToWrite(); |
| 64 | int64_t write = min(size, available); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 65 | |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 66 | AidlMQ::MemTransaction tx; |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 67 | int64_t ret = 0; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 68 | if (mDvrMQ->beginWrite(write, &tx)) { |
| 69 | auto first = tx.getFirstRegion(); |
| 70 | auto data = first.getAddress(); |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 71 | int64_t length = first.getLength(); |
| 72 | int64_t firstToWrite = min(length, write); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 73 | ret = read(mFd, data, firstToWrite); |
| 74 | |
| 75 | if (ret < 0) { |
| 76 | ALOGE("Failed to read from FD: %s", strerror(errno)); |
| 77 | return -1; |
| 78 | } |
| 79 | if (ret < firstToWrite) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 80 | ALOGW("file to MQ, first region: %" PRIu64 " bytes to write, but %" PRIu64 |
| 81 | " bytes written", |
| 82 | firstToWrite, ret); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 83 | } else if (firstToWrite < write) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 84 | ALOGV("write second region: %" PRIu64 " bytes written, %" PRIu64 " bytes in total", ret, |
| 85 | write); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 86 | auto second = tx.getSecondRegion(); |
| 87 | data = second.getAddress(); |
| 88 | length = second.getLength(); |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 89 | int64_t secondToWrite = std::min(length, write - firstToWrite); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 90 | ret += read(mFd, data, secondToWrite); |
| 91 | } |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 92 | ALOGV("file to MQ: %" PRIu64 " bytes need to be written, %" PRIu64 " bytes written", write, |
| 93 | ret); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 94 | if (!mDvrMQ->commitWrite(ret)) { |
| 95 | ALOGE("Error: failed to commit write!"); |
| 96 | return -1; |
| 97 | } |
| 98 | } else { |
| 99 | ALOGE("dvrMq.beginWrite failed"); |
| 100 | } |
| 101 | |
| 102 | if (ret > 0) { |
| 103 | mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY)); |
| 104 | } |
| 105 | return ret; |
| 106 | } |
| 107 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 108 | int64_t DvrClient::readFromBuffer(int8_t* buffer, int64_t size) { |
| 109 | if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 110 | ALOGE("Failed to readFromBuffer. DVR mq is not configured"); |
| 111 | return -1; |
| 112 | } |
| 113 | if (buffer == nullptr) { |
| 114 | ALOGE("Failed to readFromBuffer. Buffer can't be null"); |
| 115 | return -1; |
| 116 | } |
| 117 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 118 | int64_t available = mDvrMQ->availableToWrite(); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 119 | size = min(size, available); |
| 120 | |
| 121 | if (mDvrMQ->write(buffer, size)) { |
| 122 | mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY)); |
| 123 | } else { |
| 124 | ALOGD("Failed to write FMQ"); |
| 125 | return -1; |
| 126 | } |
| 127 | return size; |
| 128 | } |
| 129 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 130 | int64_t DvrClient::writeToFile(int64_t size) { |
| 131 | if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 132 | ALOGE("Failed to writeToFile. DVR mq is not configured"); |
| 133 | return -1; |
| 134 | } |
| 135 | if (mFd < 0) { |
| 136 | ALOGE("Failed to writeToFile. File is not configured"); |
| 137 | return -1; |
| 138 | } |
| 139 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 140 | int64_t available = mDvrMQ->availableToRead(); |
| 141 | int64_t toRead = min(size, available); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 142 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 143 | int64_t ret = 0; |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 144 | AidlMQ::MemTransaction tx; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 145 | if (mDvrMQ->beginRead(toRead, &tx)) { |
| 146 | auto first = tx.getFirstRegion(); |
| 147 | auto data = first.getAddress(); |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 148 | int64_t length = first.getLength(); |
| 149 | int64_t firstToRead = std::min(length, toRead); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 150 | ret = write(mFd, data, firstToRead); |
| 151 | |
| 152 | if (ret < 0) { |
| 153 | ALOGE("Failed to write to FD: %s", strerror(errno)); |
| 154 | return -1; |
| 155 | } |
| 156 | if (ret < firstToRead) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 157 | ALOGW("MQ to file: %" PRIu64 " bytes read, but %" PRIu64 " bytes written", firstToRead, |
| 158 | ret); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 159 | } else if (firstToRead < toRead) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 160 | ALOGV("read second region: %" PRIu64 " bytes read, %" PRIu64 " bytes in total", ret, |
| 161 | toRead); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 162 | auto second = tx.getSecondRegion(); |
| 163 | data = second.getAddress(); |
| 164 | length = second.getLength(); |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 165 | int32_t secondToRead = toRead - firstToRead; |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 166 | ret += write(mFd, data, secondToRead); |
| 167 | } |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 168 | ALOGV("MQ to file: %" PRIu64 " bytes to be read, %" PRIu64 " bytes written", toRead, ret); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 169 | if (!mDvrMQ->commitRead(ret)) { |
| 170 | ALOGE("Error: failed to commit read!"); |
| 171 | return 0; |
| 172 | } |
| 173 | } else { |
| 174 | ALOGE("dvrMq.beginRead failed"); |
| 175 | } |
| 176 | if (ret > 0) { |
| 177 | mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED)); |
| 178 | } |
| 179 | |
| 180 | return ret; |
| 181 | } |
| 182 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 183 | int64_t DvrClient::writeToBuffer(int8_t* buffer, int64_t size) { |
| 184 | if (mDvrMQ == nullptr || mDvrMQEventFlag == nullptr) { |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 185 | ALOGE("Failed to writetoBuffer. DVR mq is not configured"); |
| 186 | return -1; |
| 187 | } |
| 188 | if (buffer == nullptr) { |
| 189 | ALOGE("Failed to writetoBuffer. Buffer can't be null"); |
| 190 | return -1; |
| 191 | } |
| 192 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 193 | int64_t available = mDvrMQ->availableToRead(); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 194 | size = min(size, available); |
| 195 | |
| 196 | if (mDvrMQ->read(buffer, size)) { |
| 197 | mDvrMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_CONSUMED)); |
| 198 | } else { |
| 199 | ALOGD("Failed to write FMQ"); |
| 200 | return -1; |
| 201 | } |
| 202 | return size; |
| 203 | } |
| 204 | |
Hongguang | 90dd674 | 2021-11-23 13:24:00 -0800 | [diff] [blame] | 205 | int64_t DvrClient::seekFile(int64_t pos) { |
| 206 | if (mFd < 0) { |
| 207 | ALOGE("Failed to seekFile. File is not configured"); |
| 208 | return -1; |
| 209 | } |
| 210 | return lseek64(mFd, pos, SEEK_SET); |
| 211 | } |
| 212 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 213 | Result DvrClient::configure(DvrSettings settings) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 214 | if (mTunerDvr != nullptr) { |
| 215 | Status s = mTunerDvr->configure(settings); |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 216 | Result res = ClientHelper::getServiceSpecificErrorCode(s); |
| 217 | if (res != Result::SUCCESS) { |
| 218 | return res; |
| 219 | } |
| 220 | |
Amy Zhang | b5809be | 2021-01-26 16:27:23 -0800 | [diff] [blame] | 221 | AidlMQDesc aidlMqDesc; |
| 222 | s = mTunerDvr->getQueueDesc(&aidlMqDesc); |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 223 | res = ClientHelper::getServiceSpecificErrorCode(s); |
| 224 | if (res != Result::SUCCESS) { |
| 225 | return res; |
| 226 | } |
Amy Zhang | b5809be | 2021-01-26 16:27:23 -0800 | [diff] [blame] | 227 | mDvrMQ = new (nothrow) AidlMQ(aidlMqDesc); |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 228 | EventFlag::createEventFlag(mDvrMQ->getEventFlagWord(), &mDvrMQEventFlag); |
| 229 | return res; |
| 230 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 231 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 232 | return Result::INVALID_STATE; |
| 233 | } |
| 234 | |
| 235 | Result DvrClient::attachFilter(sp<FilterClient> filterClient) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 236 | if (filterClient == nullptr) { |
| 237 | return Result::INVALID_ARGUMENT; |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 238 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 239 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 240 | if (mTunerDvr != nullptr) { |
| 241 | Status s = mTunerDvr->attachFilter(filterClient->getAidlFilter()); |
| 242 | return ClientHelper::getServiceSpecificErrorCode(s); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | return Result::INVALID_STATE; |
| 246 | } |
| 247 | |
| 248 | Result DvrClient::detachFilter(sp<FilterClient> filterClient) { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 249 | if (filterClient == nullptr) { |
| 250 | return Result::INVALID_ARGUMENT; |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 251 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 252 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 253 | if (mTunerDvr != nullptr) { |
| 254 | Status s = mTunerDvr->detachFilter(filterClient->getAidlFilter()); |
| 255 | return ClientHelper::getServiceSpecificErrorCode(s); |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | return Result::INVALID_STATE; |
| 259 | } |
| 260 | |
| 261 | Result DvrClient::start() { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 262 | if (mTunerDvr != nullptr) { |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 263 | Status s = mTunerDvr->start(); |
| 264 | return ClientHelper::getServiceSpecificErrorCode(s); |
| 265 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 266 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 267 | return Result::INVALID_STATE; |
| 268 | } |
| 269 | |
| 270 | Result DvrClient::stop() { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 271 | if (mTunerDvr != nullptr) { |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 272 | Status s = mTunerDvr->stop(); |
| 273 | return ClientHelper::getServiceSpecificErrorCode(s); |
| 274 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 275 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 276 | return Result::INVALID_STATE; |
| 277 | } |
| 278 | |
| 279 | Result DvrClient::flush() { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 280 | if (mTunerDvr != nullptr) { |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 281 | Status s = mTunerDvr->flush(); |
| 282 | return ClientHelper::getServiceSpecificErrorCode(s); |
| 283 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 284 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 285 | return Result::INVALID_STATE; |
| 286 | } |
| 287 | |
| 288 | Result DvrClient::close() { |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 289 | if (mDvrMQEventFlag != nullptr) { |
Henry Fang | bc30a4b | 2021-03-15 13:27:37 -0700 | [diff] [blame] | 290 | EventFlag::deleteEventFlag(&mDvrMQEventFlag); |
Gareth Fenn | 0f633885 | 2021-11-04 16:28:44 +0000 | [diff] [blame] | 291 | mDvrMQEventFlag = nullptr; |
Henry Fang | bc30a4b | 2021-03-15 13:27:37 -0700 | [diff] [blame] | 292 | } |
Gareth Fenn | 0f633885 | 2021-11-04 16:28:44 +0000 | [diff] [blame] | 293 | if (mDvrMQ != nullptr) { |
| 294 | delete mDvrMQ; |
| 295 | mDvrMQ = nullptr; |
| 296 | } |
Henry Fang | bc30a4b | 2021-03-15 13:27:37 -0700 | [diff] [blame] | 297 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 298 | if (mTunerDvr != nullptr) { |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 299 | Status s = mTunerDvr->close(); |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 300 | mTunerDvr = nullptr; |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 301 | return ClientHelper::getServiceSpecificErrorCode(s); |
| 302 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 303 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 304 | return Result::INVALID_STATE; |
| 305 | } |
Ray Chin | f0a1ec8 | 2022-09-15 14:28:37 +0800 | [diff] [blame] | 306 | Result DvrClient::setStatusCheckIntervalHint(int64_t durationInMs) { |
| 307 | if (mTunerDvr == nullptr) { |
| 308 | return Result::INVALID_STATE; |
| 309 | } |
| 310 | if (durationInMs < 0) { |
| 311 | return Result::INVALID_ARGUMENT; |
| 312 | } |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 313 | |
Ray Chin | f0a1ec8 | 2022-09-15 14:28:37 +0800 | [diff] [blame] | 314 | Status s = mTunerDvr->setStatusCheckIntervalHint(durationInMs); |
| 315 | return ClientHelper::getServiceSpecificErrorCode(s); |
| 316 | } |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 317 | /////////////// TunerDvrCallback /////////////////////// |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 318 | TunerDvrCallback::TunerDvrCallback(sp<DvrClientCallback> dvrClientCallback) |
| 319 | : mDvrClientCallback(dvrClientCallback) {} |
| 320 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 321 | Status TunerDvrCallback::onRecordStatus(RecordStatus status) { |
| 322 | if (mDvrClientCallback != nullptr) { |
| 323 | mDvrClientCallback->onRecordStatus(status); |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 324 | return Status::ok(); |
| 325 | } |
| 326 | return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| 327 | } |
| 328 | |
Hongguang | 56637e9 | 2021-07-28 17:32:55 -0700 | [diff] [blame] | 329 | Status TunerDvrCallback::onPlaybackStatus(PlaybackStatus status) { |
| 330 | if (mDvrClientCallback != nullptr) { |
| 331 | mDvrClientCallback->onPlaybackStatus(status); |
Amy Zhang | 2d7026b | 2021-01-22 18:07:51 -0800 | [diff] [blame] | 332 | return Status::ok(); |
| 333 | } |
| 334 | return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE)); |
| 335 | } |
| 336 | |
Amy Zhang | 9a9ed60 | 2020-12-07 16:37:33 -0800 | [diff] [blame] | 337 | } // namespace android |