tv/tuner/aidl/vts/functional/DvrTests.cpp - android_hardware_interfaces - Gitiles

 /*
  * Copyright 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "DvrTests.h"

 #include <aidl/android/hardware/tv/tuner/DemuxQueueNotifyBits.h>

 void DvrCallback::startPlaybackInputThread(string& dataInputFile, PlaybackSettings& settings,
                                            MQDesc& playbackMQDescriptor) {
     mInputDataFile = dataInputFile;
     mPlaybackSettings = settings;
     mPlaybackMQ = std::make_unique<FilterMQ>(playbackMQDescriptor, true /* resetPointers */);
     EXPECT_TRUE(mPlaybackMQ);

     mPlaybackThread = std::thread(&DvrCallback::playbackThreadLoop, this);
 }

 void DvrCallback::stopPlaybackThread() {
     mPlaybackThreadRunning = false;
     mKeepWritingPlaybackFMQ = false;

     if (mPlaybackThread.joinable()) {
         mPlaybackThread.join();
     }
 }

 void DvrCallback::playbackThreadLoop() {
     mPlaybackThreadRunning = true;
     mKeepWritingPlaybackFMQ = true;

     // Create the EventFlag that is used to signal the HAL impl that data have been
     // written into the Playback FMQ
     EventFlag* playbackMQEventFlag;
     EXPECT_TRUE(EventFlag::createEventFlag(mPlaybackMQ->getEventFlagWord(), &playbackMQEventFlag) ==
                 android::OK);

     int fd = open(mInputDataFile.c_str(), O_RDONLY | O_LARGEFILE);
     int readBytes;
     uint32_t regionSize = 0;
     int8_t* buffer;
     ALOGW("[vts] playback thread loop start %s", mInputDataFile.c_str());
     if (fd < 0) {
         mPlaybackThreadRunning = false;
         ALOGW("[vts] Error %s", strerror(errno));
     }

     while (mPlaybackThreadRunning) {
         while (mKeepWritingPlaybackFMQ) {
             int totalWrite = mPlaybackMQ->availableToWrite();
             if (totalWrite * 4 < mPlaybackMQ->getQuantumCount()) {
                 // Wait for the HAL implementation to read more data then write.
                 continue;
             }
             AidlMessageQueue<int8_t, SynchronizedReadWrite>::MemTransaction memTx;
             if (!mPlaybackMQ->beginWrite(totalWrite, &memTx)) {
                 ALOGW("[vts] Fail to write into Playback fmq.");
                 mPlaybackThreadRunning = false;
                 break;
             }
             auto first = memTx.getFirstRegion();
             buffer = first.getAddress();
             regionSize = first.getLength();

             if (regionSize > 0) {
                 readBytes = read(fd, buffer, regionSize);
                 if (readBytes <= 0) {
                     if (readBytes < 0) {
                         ALOGW("[vts] Read from %s failed.", mInputDataFile.c_str());
                     } else {
                         ALOGW("[vts] playback input EOF.");
                     }
                     mPlaybackThreadRunning = false;
                     break;
                 }
             }
             if (regionSize == 0 || (readBytes == regionSize && regionSize < totalWrite)) {
                 auto second = memTx.getSecondRegion();
                 buffer = second.getAddress();
                 regionSize = second.getLength();
                 int ret = read(fd, buffer, regionSize);
                 if (ret <= 0) {
                     if (ret < 0) {
                         ALOGW("[vts] Read from %s failed.", mInputDataFile.c_str());
                     } else {
                         ALOGW("[vts] playback input EOF.");
                     }
                     mPlaybackThreadRunning = false;
                     break;
                 }
                 readBytes += ret;
             }
             if (!mPlaybackMQ->commitWrite(readBytes)) {
                 ALOGW("[vts] Failed to commit write playback fmq.");
                 mPlaybackThreadRunning = false;
                 break;
             }
             playbackMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY));
         }
     }

     mPlaybackThreadRunning = false;
     ALOGW("[vts] Playback thread end.");
     close(fd);
 }

 void DvrCallback::testRecordOutput() {
     bool passed = true;
     {
         android::Mutex::Autolock autoLock(mMsgLock);
         while (mDataOutputBuffer.empty()) {
             if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
                 EXPECT_TRUE(false) << "record output matching pid does not output within timeout";
                 passed = false;
                 break;
             }
         }
     }
     stopRecordThread();
     if (passed) ALOGW("[vts] record pass and stop");
 }

 void DvrCallback::startRecordOutputThread(RecordSettings /* recordSettings */,
                                           MQDesc& recordMQDescriptor) {
     mRecordMQ = std::make_unique<FilterMQ>(recordMQDescriptor, true /* resetPointers */);
     EXPECT_TRUE(mRecordMQ);

     mRecordThread = std::thread(&DvrCallback::recordThreadLoop, this);
 }

 void DvrCallback::recordThreadLoop() {
     ALOGD("[vts] DvrCallback record threadLoop start.");
     mRecordThreadRunning = true;
     mKeepReadingRecordFMQ = true;

     // Create the EventFlag that is used to signal the HAL impl that data have been
     // read from the Record FMQ
     EventFlag* recordMQEventFlag;
     EXPECT_TRUE(EventFlag::createEventFlag(mRecordMQ->getEventFlagWord(), &recordMQEventFlag) ==
                 android::OK);

     while (mRecordThreadRunning) {
         while (mKeepReadingRecordFMQ) {
             uint32_t efState = 0;
             android::status_t status = recordMQEventFlag->wait(
                     static_cast<int32_t>(DemuxQueueNotifyBits::DATA_READY), &efState, WAIT_TIMEOUT,
                     true /* retry on spurious wake */);
             if (status != android::OK) {
                 ALOGD("[vts] wait for data ready on the record FMQ");
                 continue;
             }
             // Our current implementation filter the data and write it into the filter FMQ
             // immediately after the DATA_READY from the VTS/framework
             if (!readRecordFMQ()) {
                 ALOGD("[vts] record data failed to be filtered. Ending thread");
                 mRecordThreadRunning = false;
                 break;
             }
         }
     }

     mRecordThreadRunning = false;
     ALOGD("[vts] record thread ended.");
 }

 bool DvrCallback::readRecordFMQ() {
     android::Mutex::Autolock autoLock(mMsgLock);
     bool result = false;
     int readSize = mRecordMQ->availableToRead();
     mDataOutputBuffer.clear();
     mDataOutputBuffer.resize(readSize);
     result = mRecordMQ->read(mDataOutputBuffer.data(), readSize);
     EXPECT_TRUE(result) << "can't read from Record MQ";
     mMsgCondition.signal();
     return result;
 }

 void DvrCallback::stopRecordThread() {
     mKeepReadingRecordFMQ = false;
     mRecordThreadRunning = false;

     if (mRecordThread.joinable()) {
         mRecordThread.join();
     }
 }

 AssertionResult DvrTests::openDvrInDemux(DvrType type, int32_t bufferSize) {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";

     // Create dvr callback
     if (type == DvrType::PLAYBACK) {
         mDvrPlaybackCallback = ndk::SharedRefBase::make<DvrCallback>();
         status = mDemux->openDvr(type, bufferSize, mDvrPlaybackCallback, &mDvrPlayback);
         if (status.isOk()) {
             mDvrPlaybackCallback->setDvr(mDvrPlayback);
         }
     }

     if (type == DvrType::RECORD) {
         mDvrRecordCallback = ndk::SharedRefBase::make<DvrCallback>();
         status = mDemux->openDvr(type, bufferSize, mDvrRecordCallback, &mDvrRecord);
         if (status.isOk()) {
             mDvrRecordCallback->setDvr(mDvrRecord);
         }
     }

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::configDvrPlayback(DvrSettings setting) {
     ndk::ScopedAStatus status = mDvrPlayback->configure(setting);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::configDvrRecord(DvrSettings setting) {
     ndk::ScopedAStatus status = mDvrRecord->configure(setting);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::getDvrPlaybackMQDescriptor() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

     status = mDvrPlayback->getQueueDesc(&mDvrPlaybackMQDescriptor);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::getDvrRecordMQDescriptor() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->getQueueDesc(&mDvrRecordMQDescriptor);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::attachFilterToDvr(std::shared_ptr<IFilter> filter) {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->attachFilter(filter);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::detachFilterToDvr(std::shared_ptr<IFilter> filter) {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->detachFilter(filter);

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::startDvrPlayback() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

     status = mDvrPlayback->start();

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::stopDvrPlayback() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

     status = mDvrPlayback->stop();

     return AssertionResult(status.isOk());
 }

 void DvrTests::closeDvrPlayback() {
     ASSERT_TRUE(mDemux);
     ASSERT_TRUE(mDvrPlayback);
     ASSERT_TRUE(mDvrPlayback->close().isOk());
 }

 AssertionResult DvrTests::startDvrRecord() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->start();

     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::stopDvrRecord() {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->stop();

     return AssertionResult(status.isOk());
 }

 void DvrTests::closeDvrRecord() {
     ASSERT_TRUE(mDemux);
     ASSERT_TRUE(mDvrRecord);
     ASSERT_TRUE(mDvrRecord->close().isOk());
 }

 AssertionResult DvrTests::setPlaybackStatusCheckIntervalHint(int64_t milliseconds) {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

     status = mDvrPlayback->setStatusCheckIntervalHint(milliseconds);

     if (getDvrPlaybackInterfaceVersion() < 2) {
         return AssertionResult(status.getStatus() == STATUS_UNKNOWN_TRANSACTION);
     }
     return AssertionResult(status.isOk());
 }

 AssertionResult DvrTests::setRecordStatusCheckIntervalHint(int64_t milliseconds) {
     ndk::ScopedAStatus status;
     EXPECT_TRUE(mDemux) << "Test with openDemux first.";
     EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

     status = mDvrRecord->setStatusCheckIntervalHint(milliseconds);

     if (getDvrRecordInterfaceVersion() < 2) {
         return AssertionResult(status.getStatus() == STATUS_UNKNOWN_TRANSACTION);
     }
     return AssertionResult(status.isOk());
 }

 int32_t DvrTests::getDvrPlaybackInterfaceVersion() {
     int32_t version;
     mDvrPlayback->getInterfaceVersion(&version);
     return version;
 }

 int32_t DvrTests::getDvrRecordInterfaceVersion() {
     int32_t version;
     mDvrRecord->getInterfaceVersion(&version);
     return version;
 }
	/*
	* Copyright 2021 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "DvrTests.h"

	#include <aidl/android/hardware/tv/tuner/DemuxQueueNotifyBits.h>

	void DvrCallback::startPlaybackInputThread(string& dataInputFile, PlaybackSettings& settings,
	MQDesc& playbackMQDescriptor) {
	mInputDataFile = dataInputFile;
	mPlaybackSettings = settings;
	mPlaybackMQ = std::make_unique<FilterMQ>(playbackMQDescriptor, true /* resetPointers */);
	EXPECT_TRUE(mPlaybackMQ);

	mPlaybackThread = std::thread(&DvrCallback::playbackThreadLoop, this);
	}

	void DvrCallback::stopPlaybackThread() {
	mPlaybackThreadRunning = false;
	mKeepWritingPlaybackFMQ = false;

	if (mPlaybackThread.joinable()) {
	mPlaybackThread.join();
	}
	}

	void DvrCallback::playbackThreadLoop() {
	mPlaybackThreadRunning = true;
	mKeepWritingPlaybackFMQ = true;

	// Create the EventFlag that is used to signal the HAL impl that data have been
	// written into the Playback FMQ
	EventFlag* playbackMQEventFlag;
	EXPECT_TRUE(EventFlag::createEventFlag(mPlaybackMQ->getEventFlagWord(), &playbackMQEventFlag) ==
	android::OK);

	int fd = open(mInputDataFile.c_str(), O_RDONLY \| O_LARGEFILE);
	int readBytes;
	uint32_t regionSize = 0;
	int8_t* buffer;
	ALOGW("[vts] playback thread loop start %s", mInputDataFile.c_str());
	if (fd < 0) {
	mPlaybackThreadRunning = false;
	ALOGW("[vts] Error %s", strerror(errno));
	}

	while (mPlaybackThreadRunning) {
	while (mKeepWritingPlaybackFMQ) {
	int totalWrite = mPlaybackMQ->availableToWrite();
	if (totalWrite * 4 < mPlaybackMQ->getQuantumCount()) {
	// Wait for the HAL implementation to read more data then write.
	continue;
	}
	AidlMessageQueue<int8_t, SynchronizedReadWrite>::MemTransaction memTx;
	if (!mPlaybackMQ->beginWrite(totalWrite, &memTx)) {
	ALOGW("[vts] Fail to write into Playback fmq.");
	mPlaybackThreadRunning = false;
	break;
	}
	auto first = memTx.getFirstRegion();
	buffer = first.getAddress();
	regionSize = first.getLength();

	if (regionSize > 0) {
	readBytes = read(fd, buffer, regionSize);
	if (readBytes <= 0) {
	if (readBytes < 0) {
	ALOGW("[vts] Read from %s failed.", mInputDataFile.c_str());
	} else {
	ALOGW("[vts] playback input EOF.");
	}
	mPlaybackThreadRunning = false;
	break;
	}
	}
	if (regionSize == 0 \|\| (readBytes == regionSize && regionSize < totalWrite)) {
	auto second = memTx.getSecondRegion();
	buffer = second.getAddress();
	regionSize = second.getLength();
	int ret = read(fd, buffer, regionSize);
	if (ret <= 0) {
	if (ret < 0) {
	ALOGW("[vts] Read from %s failed.", mInputDataFile.c_str());
	} else {
	ALOGW("[vts] playback input EOF.");
	}
	mPlaybackThreadRunning = false;
	break;
	}
	readBytes += ret;
	}
	if (!mPlaybackMQ->commitWrite(readBytes)) {
	ALOGW("[vts] Failed to commit write playback fmq.");
	mPlaybackThreadRunning = false;
	break;
	}
	playbackMQEventFlag->wake(static_cast<uint32_t>(DemuxQueueNotifyBits::DATA_READY));
	}
	}

	mPlaybackThreadRunning = false;
	ALOGW("[vts] Playback thread end.");
	close(fd);
	}

	void DvrCallback::testRecordOutput() {
	bool passed = true;
	{
	android::Mutex::Autolock autoLock(mMsgLock);
	while (mDataOutputBuffer.empty()) {
	if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
	EXPECT_TRUE(false) << "record output matching pid does not output within timeout";
	passed = false;
	break;
	}
	}
	}
	stopRecordThread();
	if (passed) ALOGW("[vts] record pass and stop");
	}

	void DvrCallback::startRecordOutputThread(RecordSettings /* recordSettings */,
	MQDesc& recordMQDescriptor) {
	mRecordMQ = std::make_unique<FilterMQ>(recordMQDescriptor, true /* resetPointers */);
	EXPECT_TRUE(mRecordMQ);

	mRecordThread = std::thread(&DvrCallback::recordThreadLoop, this);
	}

	void DvrCallback::recordThreadLoop() {
	ALOGD("[vts] DvrCallback record threadLoop start.");
	mRecordThreadRunning = true;
	mKeepReadingRecordFMQ = true;

	// Create the EventFlag that is used to signal the HAL impl that data have been
	// read from the Record FMQ
	EventFlag* recordMQEventFlag;
	EXPECT_TRUE(EventFlag::createEventFlag(mRecordMQ->getEventFlagWord(), &recordMQEventFlag) ==
	android::OK);

	while (mRecordThreadRunning) {
	while (mKeepReadingRecordFMQ) {
	uint32_t efState = 0;
	android::status_t status = recordMQEventFlag->wait(
	static_cast<int32_t>(DemuxQueueNotifyBits::DATA_READY), &efState, WAIT_TIMEOUT,
	true /* retry on spurious wake */);
	if (status != android::OK) {
	ALOGD("[vts] wait for data ready on the record FMQ");
	continue;
	}
	// Our current implementation filter the data and write it into the filter FMQ
	// immediately after the DATA_READY from the VTS/framework
	if (!readRecordFMQ()) {
	ALOGD("[vts] record data failed to be filtered. Ending thread");
	mRecordThreadRunning = false;
	break;
	}
	}
	}

	mRecordThreadRunning = false;
	ALOGD("[vts] record thread ended.");
	}

	bool DvrCallback::readRecordFMQ() {
	android::Mutex::Autolock autoLock(mMsgLock);
	bool result = false;
	int readSize = mRecordMQ->availableToRead();
	mDataOutputBuffer.clear();
	mDataOutputBuffer.resize(readSize);
	result = mRecordMQ->read(mDataOutputBuffer.data(), readSize);
	EXPECT_TRUE(result) << "can't read from Record MQ";
	mMsgCondition.signal();
	return result;
	}

	void DvrCallback::stopRecordThread() {
	mKeepReadingRecordFMQ = false;
	mRecordThreadRunning = false;

	if (mRecordThread.joinable()) {
	mRecordThread.join();
	}
	}

	AssertionResult DvrTests::openDvrInDemux(DvrType type, int32_t bufferSize) {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";

	// Create dvr callback
	if (type == DvrType::PLAYBACK) {
	mDvrPlaybackCallback = ndk::SharedRefBase::make<DvrCallback>();
	status = mDemux->openDvr(type, bufferSize, mDvrPlaybackCallback, &mDvrPlayback);
	if (status.isOk()) {
	mDvrPlaybackCallback->setDvr(mDvrPlayback);
	}
	}

	if (type == DvrType::RECORD) {
	mDvrRecordCallback = ndk::SharedRefBase::make<DvrCallback>();
	status = mDemux->openDvr(type, bufferSize, mDvrRecordCallback, &mDvrRecord);
	if (status.isOk()) {
	mDvrRecordCallback->setDvr(mDvrRecord);
	}
	}

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::configDvrPlayback(DvrSettings setting) {
	ndk::ScopedAStatus status = mDvrPlayback->configure(setting);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::configDvrRecord(DvrSettings setting) {
	ndk::ScopedAStatus status = mDvrRecord->configure(setting);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::getDvrPlaybackMQDescriptor() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

	status = mDvrPlayback->getQueueDesc(&mDvrPlaybackMQDescriptor);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::getDvrRecordMQDescriptor() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->getQueueDesc(&mDvrRecordMQDescriptor);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::attachFilterToDvr(std::shared_ptr<IFilter> filter) {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->attachFilter(filter);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::detachFilterToDvr(std::shared_ptr<IFilter> filter) {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->detachFilter(filter);

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::startDvrPlayback() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

	status = mDvrPlayback->start();

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::stopDvrPlayback() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

	status = mDvrPlayback->stop();

	return AssertionResult(status.isOk());
	}

	void DvrTests::closeDvrPlayback() {
	ASSERT_TRUE(mDemux);
	ASSERT_TRUE(mDvrPlayback);
	ASSERT_TRUE(mDvrPlayback->close().isOk());
	}

	AssertionResult DvrTests::startDvrRecord() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->start();

	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::stopDvrRecord() {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->stop();

	return AssertionResult(status.isOk());
	}

	void DvrTests::closeDvrRecord() {
	ASSERT_TRUE(mDemux);
	ASSERT_TRUE(mDvrRecord);
	ASSERT_TRUE(mDvrRecord->close().isOk());
	}

	AssertionResult DvrTests::setPlaybackStatusCheckIntervalHint(int64_t milliseconds) {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrPlayback) << "Test with openDvr first.";

	status = mDvrPlayback->setStatusCheckIntervalHint(milliseconds);

	if (getDvrPlaybackInterfaceVersion() < 2) {
	return AssertionResult(status.getStatus() == STATUS_UNKNOWN_TRANSACTION);
	}
	return AssertionResult(status.isOk());
	}

	AssertionResult DvrTests::setRecordStatusCheckIntervalHint(int64_t milliseconds) {
	ndk::ScopedAStatus status;
	EXPECT_TRUE(mDemux) << "Test with openDemux first.";
	EXPECT_TRUE(mDvrRecord) << "Test with openDvr first.";

	status = mDvrRecord->setStatusCheckIntervalHint(milliseconds);

	if (getDvrRecordInterfaceVersion() < 2) {
	return AssertionResult(status.getStatus() == STATUS_UNKNOWN_TRANSACTION);
	}
	return AssertionResult(status.isOk());
	}

	int32_t DvrTests::getDvrPlaybackInterfaceVersion() {
	int32_t version;
	mDvrPlayback->getInterfaceVersion(&version);
	return version;
	}

	int32_t DvrTests::getDvrRecordInterfaceVersion() {
	int32_t version;
	mDvrRecord->getInterfaceVersion(&version);
	return version;
	}