StreamOutHalHidl::~StreamOutHalHidl() {
if (mStream != 0) {
if (mCallback.unsafe_get()) {
processReturn("clearCallback", mStream->clearCallback());
}
processReturn("close", mStream->close());
mStream.clear();
}
mCallback.clear();
hardware::IPCThreadState::self()->flushCommands();
if (mEfGroup) {
EventFlag::deleteEventFlag(&mEfGroup);
}
}
status_t StreamInHalHidl::callReaderThread(
const ReadParameters& params, const char* cmdName,
StreamInHalHidl::ReaderCallback callback) {
if (!mCommandMQ->write(¶ms)) {
ALOGW("command message queue write failed");
return -EAGAIN;
}
mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL));
// TODO: Remove manual event flag handling once blocking MQ is implemented. b/33815422
uint32_t efState = 0;
retry:
status_t ret = mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY), &efState);
if (efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY)) {
ReadStatus readStatus;
readStatus.retval = Result::NOT_INITIALIZED;
if (!mStatusMQ->read(&readStatus)) {
ALOGE("status message read failed for \"%s\"", cmdName);
}
if (readStatus.retval == Result::OK) {
ret = OK;
callback(readStatus);
} else {
ret = processReturn(cmdName, readStatus.retval);
}
return ret;
}
if (ret == -EAGAIN || ret == -EINTR) {
// Spurious wakeup. This normally retries no more than once.
goto retry;
}
return ret;
}
status_t StreamHalHidl::setParameters(const String8& kvPairs) {
if (!mStream) return NO_INIT;
hidl_vec<ParameterValue> hidlParams;
status_t status = parametersFromHal(kvPairs, &hidlParams);
if (status != OK) return status;
return processReturn("setParameters", mStream->setParameters(hidlParams));
}
void
TxSummary::processGltx(const Gltx& gltx)
{
Employee employee;
findEmployee(gltx.employeeId(), employee);
EmployeeInfo& info = findEmployeeInfo(employee);
// Voided transactions just get counted
if (!gltx.isActive()) {
info.voidTxCnt++;
return;
}
// Further processing based on type
switch (gltx.dataType()) {
case DataObject::INVOICE: processInvoice(info, gltx); break;
case DataObject::RETURN: processReturn(info, gltx); break;
case DataObject::PAYOUT: processPayout(info, gltx); break;
case DataObject::RECEIPT: processPayment(info, gltx); break;
case DataObject::WITHDRAW: processWithdraw(info, gltx); break;
case DataObject::NOSALE: processNosale(info, gltx); break;
case DataObject::TEND_ADJUST: processTenderAdjust(info, gltx); break;
default: processOther(info, gltx);
}
}
status_t StreamHalHidl::dump(int fd) {
if (!mStream) return NO_INIT;
native_handle_t* hidlHandle = native_handle_create(1, 0);
hidlHandle->data[0] = fd;
Return<void> ret = mStream->debugDump(hidlHandle);
native_handle_delete(hidlHandle);
return processReturn("dump", ret);
}
status_t StreamOutHalHidl::supportsPauseAndResume(bool *supportsPause, bool *supportsResume) {
if (mStream == 0) return NO_INIT;
Return<void> ret = mStream->supportsPauseAndResume(
[&](bool p, bool r) {
*supportsPause = p;
*supportsResume = r;
});
return processReturn("supportsPauseAndResume", ret);
}
status_t StreamOutHalHidl::setCallback(wp<StreamOutHalInterfaceCallback> callback) {
if (mStream == 0) return NO_INIT;
status_t status = processReturn(
"setCallback", mStream->setCallback(new StreamOutCallback(this)));
if (status == OK) {
mCallback = callback;
}
return status;
}
StreamInHalHidl::~StreamInHalHidl() {
if (mStream != 0) {
processReturn("close", mStream->close());
mStream.clear();
hardware::IPCThreadState::self()->flushCommands();
}
if (mEfGroup) {
EventFlag::deleteEventFlag(&mEfGroup);
}
}
status_t StreamHalHidl::getAudioProperties(
uint32_t *sampleRate, audio_channel_mask_t *mask, audio_format_t *format) {
if (!mStream) return NO_INIT;
Return<void> ret = mStream->getAudioProperties(
[&](uint32_t sr, AudioChannelMask m, AudioFormat f) {
*sampleRate = sr;
*mask = static_cast<audio_channel_mask_t>(m);
*format = static_cast<audio_format_t>(f);
});
return processReturn("getAudioProperties", ret);
}
status_t StreamOutHalHidl::getNextWriteTimestamp(int64_t *timestamp) {
if (mStream == 0) return NO_INIT;
Result retval;
Return<void> ret = mStream->getNextWriteTimestamp(
[&](Result r, int64_t t) {
retval = r;
if (retval == Result::OK) {
*timestamp = t;
}
});
return processReturn("getRenderPosition", ret, retval);
}
status_t StreamOutHalHidl::getRenderPosition(uint32_t *dspFrames) {
if (mStream == 0) return NO_INIT;
Result retval;
Return<void> ret = mStream->getRenderPosition(
[&](Result r, uint32_t d) {
retval = r;
if (retval == Result::OK) {
*dspFrames = d;
}
});
return processReturn("getRenderPosition", ret, retval);
}
status_t StreamOutHalHidl::getLatency(uint32_t *latency) {
if (mStream == 0) return NO_INIT;
if (mWriterClient == gettid() && mCommandMQ) {
return callWriterThread(
WriteCommand::GET_LATENCY, "getLatency", nullptr, 0,
[&](const WriteStatus& writeStatus) {
*latency = writeStatus.reply.latencyMs;
});
} else {
return processReturn("getLatency", mStream->getLatency(), latency);
}
}
status_t StreamHalHidl::getMmapPosition(struct audio_mmap_position *position) {
Result retval;
Return<void> ret = mStream->getMmapPosition(
[&](Result r, const MmapPosition& hidlPosition) {
retval = r;
if (retval == Result::OK) {
position->time_nanoseconds = hidlPosition.timeNanoseconds;
position->position_frames = hidlPosition.positionFrames;
}
});
return processReturn("getMmapPosition", ret, retval);
}
void CWizXmlRpcServer::on_replyFinished()
{
QNetworkReply* reply = qobject_cast<QNetworkReply *>(sender());
if (reply->error()) {
reply->deleteLater();
return;
}
QString strContentType = reply->header(QNetworkRequest::ContentTypeHeader).toString();
if (strContentType != "text/xml;charset=UTF-8") {
processError(errorContentType, 0, "Invalid content type of response");
reply->deleteLater();
return;
}
m_replyData = reply->readAll();
#ifdef WIZNOTE_DEBUG_XMLRPC
QString requestFile = QDir::tempPath() + "/WizNote/" + m_strMethodName;
QString replyFile = QDir::tempPath() + "/WizNote/on_" + m_strMethodName;
WizSaveUnicodeTextToUtf8File(requestFile, QString(m_requestData));
WizSaveUnicodeTextToUtf8File(replyFile, QString(m_replyData));
#endif
QString strXml = QString::fromUtf8(m_replyData.constData());
CWizXMLDocument doc;
if (!doc.LoadXML(strXml)) {
processError(errorXmlFormat, 0, "Invalid xml");
reply->deleteLater();
return;
}
CWizXmlRpcValue* pRet = NULL;
if (!WizXmlRpcResultFromXml(doc, &pRet)) {
processError(errorXmlRpcFormat, 0, "Can not parse xmlrpc");
reply->deleteLater();
return;
}
Q_ASSERT(pRet);
if (CWizXmlRpcFaultValue* pFault = dynamic_cast<CWizXmlRpcFaultValue *>(pRet)) {
processError(errorXmlRpcFault, pFault->GetFaultCode(), pFault->GetFaultString());
reply->deleteLater();
delete pRet;
return;
}
processReturn(*pRet);
}
status_t StreamInHalHidl::prepareForReading(size_t bufferSize) {
std::unique_ptr<CommandMQ> tempCommandMQ;
std::unique_ptr<DataMQ> tempDataMQ;
std::unique_ptr<StatusMQ> tempStatusMQ;
Result retval;
pid_t halThreadPid, halThreadTid;
Return<void> ret = mStream->prepareForReading(
1, bufferSize,
[&](Result r,
const CommandMQ::Descriptor& commandMQ,
const DataMQ::Descriptor& dataMQ,
const StatusMQ::Descriptor& statusMQ,
const ThreadInfo& halThreadInfo) {
retval = r;
if (retval == Result::OK) {
tempCommandMQ.reset(new CommandMQ(commandMQ));
tempDataMQ.reset(new DataMQ(dataMQ));
tempStatusMQ.reset(new StatusMQ(statusMQ));
if (tempDataMQ->isValid() && tempDataMQ->getEventFlagWord()) {
EventFlag::createEventFlag(tempDataMQ->getEventFlagWord(), &mEfGroup);
}
halThreadPid = halThreadInfo.pid;
halThreadTid = halThreadInfo.tid;
}
});
if (!ret.isOk() || retval != Result::OK) {
return processReturn("prepareForReading", ret, retval);
}
if (!tempCommandMQ || !tempCommandMQ->isValid() ||
!tempDataMQ || !tempDataMQ->isValid() ||
!tempStatusMQ || !tempStatusMQ->isValid() ||
!mEfGroup) {
ALOGE_IF(!tempCommandMQ, "Failed to obtain command message queue for writing");
ALOGE_IF(tempCommandMQ && !tempCommandMQ->isValid(),
"Command message queue for writing is invalid");
ALOGE_IF(!tempDataMQ, "Failed to obtain data message queue for reading");
ALOGE_IF(tempDataMQ && !tempDataMQ->isValid(), "Data message queue for reading is invalid");
ALOGE_IF(!tempStatusMQ, "Failed to obtain status message queue for reading");
ALOGE_IF(tempStatusMQ && !tempStatusMQ->isValid(),
"Status message queue for reading is invalid");
ALOGE_IF(!mEfGroup, "Event flag creation for reading failed");
return NO_INIT;
}
requestHalThreadPriority(halThreadPid, halThreadTid);
mCommandMQ = std::move(tempCommandMQ);
mDataMQ = std::move(tempDataMQ);
mStatusMQ = std::move(tempStatusMQ);
mReaderClient = gettid();
return OK;
}
status_t StreamHalHidl::getParameters(const String8& keys, String8 *values) {
values->clear();
if (!mStream) return NO_INIT;
hidl_vec<hidl_string> hidlKeys;
status_t status = keysFromHal(keys, &hidlKeys);
if (status != OK) return status;
Result retval;
Return<void> ret = mStream->getParameters(
hidlKeys,
[&](Result r, const hidl_vec<ParameterValue>& parameters) {
retval = r;
if (retval == Result::OK) {
parametersToHal(parameters, values);
}
});
return processReturn("getParameters", ret, retval);
}
status_t StreamOutHalHidl::callWriterThread(
WriteCommand cmd, const char* cmdName,
const uint8_t* data, size_t dataSize, StreamOutHalHidl::WriterCallback callback) {
if (!mCommandMQ->write(&cmd)) {
ALOGE("command message queue write failed for \"%s\"", cmdName);
return -EAGAIN;
}
if (data != nullptr) {
size_t availableToWrite = mDataMQ->availableToWrite();
if (dataSize > availableToWrite) {
ALOGW("truncating write data from %lld to %lld due to insufficient data queue space",
(long long)dataSize, (long long)availableToWrite);
dataSize = availableToWrite;
}
if (!mDataMQ->write(data, dataSize)) {
ALOGE("data message queue write failed for \"%s\"", cmdName);
}
}
mEfGroup->wake(static_cast<uint32_t>(MessageQueueFlagBits::NOT_EMPTY));
// TODO: Remove manual event flag handling once blocking MQ is implemented. b/33815422
uint32_t efState = 0;
retry:
status_t ret = mEfGroup->wait(static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL), &efState);
if (efState & static_cast<uint32_t>(MessageQueueFlagBits::NOT_FULL)) {
WriteStatus writeStatus;
writeStatus.retval = Result::NOT_INITIALIZED;
if (!mStatusMQ->read(&writeStatus)) {
ALOGE("status message read failed for \"%s\"", cmdName);
}
if (writeStatus.retval == Result::OK) {
ret = OK;
callback(writeStatus);
} else {
ret = processReturn(cmdName, writeStatus.retval);
}
return ret;
}
if (ret == -EAGAIN || ret == -EINTR) {
// Spurious wakeup. This normally retries no more than once.
goto retry;
}
return ret;
}
void WizXmlRpcServer::on_replyFinished()
{
QNetworkReply* reply = qobject_cast<QNetworkReply *>(sender());
if (reply->error()) {
reply->deleteLater();
return;
}
QString strContentType = reply->header(QNetworkRequest::ContentTypeHeader).toString();
if (strContentType != "text/xml;charset=UTF-8") {
processError(errorContentType, 0, "Invalid content type of response");
reply->deleteLater();
return;
}
QString strXml = QString::fromUtf8(reply->readAll().constData());
WizXMLDocument doc;
if (!doc.loadXML(strXml)) {
processError(errorXmlFormat, 0, "Invalid xml");
reply->deleteLater();
return;
}
WizXmlRpcValue* pRet = NULL;
if (!WizXmlRpcResultFromXml(doc, &pRet)) {
processError(errorXmlRpcFormat, 0, "Can not parse xmlrpc");
reply->deleteLater();
return;
}
Q_ASSERT(pRet);
if (WizXmlRpcFaultValue* pFault = dynamic_cast<WizXmlRpcFaultValue *>(pRet)) {
processError(errorXmlRpcFault, pFault->getFaultCode(), pFault->getFaultString());
}
processReturn(*pRet);
reply->deleteLater();
}
status_t StreamHalHidl::createMmapBuffer(int32_t minSizeFrames,
struct audio_mmap_buffer_info *info) {
Result retval;
Return<void> ret = mStream->createMmapBuffer(
minSizeFrames,
[&](Result r, const MmapBufferInfo& hidlInfo) {
retval = r;
if (retval == Result::OK) {
const native_handle *handle = hidlInfo.sharedMemory.handle();
if (handle->numFds > 0) {
info->shared_memory_fd = handle->data[0];
info->buffer_size_frames = hidlInfo.bufferSizeFrames;
info->burst_size_frames = hidlInfo.burstSizeFrames;
// info->shared_memory_address is not needed in HIDL context
info->shared_memory_address = NULL;
} else {
retval = Result::NOT_INITIALIZED;
}
}
});
return processReturn("createMmapBuffer", ret, retval);
}
status_t StreamInHalHidl::getCapturePosition(int64_t *frames, int64_t *time) {
if (mStream == 0) return NO_INIT;
if (mReaderClient == gettid() && mCommandMQ) {
ReadParameters params;
params.command = ReadCommand::GET_CAPTURE_POSITION;
return callReaderThread(params, "getCapturePosition",
[&](const ReadStatus& readStatus) {
*frames = readStatus.reply.capturePosition.frames;
*time = readStatus.reply.capturePosition.time;
});
} else {
Result retval;
Return<void> ret = mStream->getCapturePosition(
[&](Result r, uint64_t hidlFrames, uint64_t hidlTime) {
retval = r;
if (retval == Result::OK) {
*frames = hidlFrames;
*time = hidlTime;
}
});
return processReturn("getCapturePosition", ret, retval);
}
}
status_t StreamOutHalHidl::getPresentationPosition(uint64_t *frames, struct timespec *timestamp) {
if (mStream == 0) return NO_INIT;
if (mWriterClient == gettid() && mCommandMQ) {
return callWriterThread(
WriteCommand::GET_PRESENTATION_POSITION, "getPresentationPosition", nullptr, 0,
[&](const WriteStatus& writeStatus) {
*frames = writeStatus.reply.presentationPosition.frames;
timestamp->tv_sec = writeStatus.reply.presentationPosition.timeStamp.tvSec;
timestamp->tv_nsec = writeStatus.reply.presentationPosition.timeStamp.tvNSec;
});
} else {
Result retval;
Return<void> ret = mStream->getPresentationPosition(
[&](Result r, uint64_t hidlFrames, const TimeSpec& hidlTimeStamp) {
retval = r;
if (retval == Result::OK) {
*frames = hidlFrames;
timestamp->tv_sec = hidlTimeStamp.tvSec;
timestamp->tv_nsec = hidlTimeStamp.tvNSec;
}
});
return processReturn("getPresentationPosition", ret, retval);
}
}
status_t StreamInHalHidl::getFrameSize(size_t *size) {
if (mStream == 0) return NO_INIT;
return processReturn("getFrameSize", mStream->getFrameSize(), size);
}
status_t StreamHalHidl::getFormat(audio_format_t *format) {
if (!mStream) return NO_INIT;
return processReturn("getFormat", mStream->getFormat(), format);
}
status_t StreamInHalHidl::getInputFramesLost(uint32_t *framesLost) {
if (mStream == 0) return NO_INIT;
return processReturn("getInputFramesLost", mStream->getInputFramesLost(), framesLost);
}
status_t StreamHalHidl::getChannelMask(audio_channel_mask_t *mask) {
if (!mStream) return NO_INIT;
return processReturn("getChannelMask", mStream->getChannelMask(), mask);
}
status_t StreamHalHidl::getBufferSize(size_t *size) {
if (!mStream) return NO_INIT;
return processReturn("getBufferSize", mStream->getBufferSize(), size);
}
status_t StreamOutHalHidl::drain(bool earlyNotify) {
if (mStream == 0) return NO_INIT;
return processReturn(
"drain", mStream->drain(earlyNotify ? AudioDrain::EARLY_NOTIFY : AudioDrain::ALL));
}
status_t StreamInHalHidl::setGain(float gain) {
if (mStream == 0) return NO_INIT;
return processReturn("setGain", mStream->setGain(gain));
}
status_t StreamHalHidl::getSampleRate(uint32_t *rate) {
if (!mStream) return NO_INIT;
return processReturn("getSampleRate", mStream->getSampleRate(), rate);
}
status_t StreamOutHalHidl::flush() {
if (mStream == 0) return NO_INIT;
return processReturn("pause", mStream->flush());
}
