nsresult
MediaManager::GetUserMediaDevices(nsPIDOMWindow* aWindow,
nsIGetUserMediaDevicesSuccessCallback* aOnSuccess,
nsIDOMGetUserMediaErrorCallback* aOnError)
{
NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
NS_ENSURE_TRUE(aOnError, NS_ERROR_NULL_POINTER);
NS_ENSURE_TRUE(aOnSuccess, NS_ERROR_NULL_POINTER);
nsCOMPtr<nsIGetUserMediaDevicesSuccessCallback> onSuccess(aOnSuccess);
nsCOMPtr<nsIDOMGetUserMediaErrorCallback> onError(aOnError);
nsCOMPtr<nsIRunnable> gUMDRunnable = new GetUserMediaDevicesRunnable(
onSuccess.forget(), onError.forget()
);
nsCOMPtr<nsIThread> deviceThread;
nsresult rv = NS_NewThread(getter_AddRefs(deviceThread));
NS_ENSURE_SUCCESS(rv, rv);
deviceThread->Dispatch(gUMDRunnable, NS_DISPATCH_NORMAL);
return NS_OK;
}
void
SendLogsDialog::send()
{
SendLogsRequest* request = new SendLogsRequest( ui.moreInfoTextEdit->toPlainText() );
connect( request, SIGNAL( success() ), SLOT( onSuccess() ) );
connect( request, SIGNAL( error() ), SLOT( onError() ) );
QDir logDir = CoreDir::logs();
QStringList logExt( "*.log" );
// find logs
logDir.setFilter( QDir::Files | QDir::Readable );
logDir.setNameFilters( logExt );
QList<QFileInfo> logFiles = logDir.entryInfoList();
foreach( QFileInfo log, logFiles )
request->addLog( log.completeBaseName(), log.absoluteFilePath() );
request->addLogData( "clientinfo", clientInformationString() );
request->addLogData( "sysinfo", systemInformationString() );
request->send();
ui.buttonBox->setEnabled( false );
ui.moreInfoTextEdit->setEnabled( false );
ui.spinner->show();
ui.spinner->movie()->start();
}
void
getPlanInfo(const IMC::PlanDB& req)
{
if (req.plan_id.empty())
{
onFailure(DTR("undefined plan id"));
return;
}
*m_query_plan_stmt << req.plan_id;
bool found = m_query_plan_stmt->execute();
if (!found)
{
onFailure(DTR("undefined plan"));
return;
}
m_plan_info.plan_id = req.plan_id;
*m_query_plan_stmt >> m_plan_info.change_time
>> m_plan_info.change_sid
>> m_plan_info.change_sname
>> m_plan_info.md5
>> m_plan_info.plan_size;
m_reply.arg.set(m_plan_info);
m_query_plan_stmt->reset();
onSuccess();
}
void
onVehicleManeuver(const IMC::VehicleState* vs)
{
if (!execMode() || pendingReply())
return;
if (vs->flags & IMC::VehicleState::VFLG_MANEUVER_DONE)
{
if (m_plan->isDone())
{
vehicleRequest(IMC::VehicleCommand::VC_STOP_MANEUVER);
std::string comp = DTR("plan completed");
onSuccess(comp, false);
m_pcs.last_outcome = IMC::PlanControlState::LPO_SUCCESS;
m_reply.plan_id = m_spec.plan_id;
changeMode(IMC::PlanControlState::PCS_READY, comp);
}
else
{
IMC::PlanManeuver* pman = m_plan->loadNextManeuver();
startManeuver(pman);
}
}
else
{
m_pcs.man_eta = vs->maneuver_eta;
}
}
void
Work::complete(CompleteResult result)
{
CLOG(DEBUG, "Work") << "completed " << getUniqueName();
auto& succ =
mApp.getMetrics().NewMeter({"work", "unit", "success"}, "unit");
auto& fail =
mApp.getMetrics().NewMeter({"work", "unit", "failure"}, "unit");
switch (result)
{
case WORK_COMPLETE_OK:
setState(onSuccess());
break;
case WORK_COMPLETE_FAILURE:
setState(WORK_FAILURE_RETRY);
break;
case WORK_COMPLETE_FATAL:
setState(WORK_FAILURE_FATAL);
break;
}
switch (getState())
{
case WORK_SUCCESS:
succ.Mark();
CLOG(DEBUG, "Work")
<< "notifying parent of successful " << getUniqueName();
notifyParent();
break;
case WORK_FAILURE_RETRY:
fail.Mark();
onFailureRetry();
scheduleRetry();
break;
case WORK_FAILURE_RAISE:
case WORK_FAILURE_FATAL:
fail.Mark();
onFailureRaise();
CLOG(DEBUG, "Work") << "notifying parent of failed " << getUniqueName();
notifyParent();
break;
case WORK_PENDING:
succ.Mark();
advance();
break;
case WORK_RUNNING:
succ.Mark();
scheduleRun();
break;
default:
assert(false);
break;
}
}
void
deletePlan(const IMC::PlanDB& req)
{
if (req.plan_id.empty())
{
onFailure(DTR("undefined plan id"));
return;
}
inProgress();
m_db->beginTransaction();
int count = 0;
try
{
*m_delete_plan_stmt << req.plan_id;
m_delete_plan_stmt->execute(&count);
if (count)
onChange(req);
}
catch (std::runtime_error& e)
{
onFailure(e.what());
m_db->rollback();
return;
}
m_db->commit();
if (!count)
onFailure(DTR("undefined plan"));
else
onSuccess();
}
void
getPlan(const IMC::PlanDB& req)
{
if (req.plan_id.empty())
{
onFailure(DTR("undefined plan id"));
return;
}
*m_get_plan_stmt << req.plan_id;
bool found = m_get_plan_stmt->execute();
if (!found)
{
onFailure(DTR("undefined plan"));
}
else
{
Database::Blob data;
*m_get_plan_stmt >> data;
IMC::PlanSpecification* spec = new IMC::PlanSpecification;
spec->deserializeFields((const uint8_t*)&data[0], data.size());
m_reply.arg.set(spec);
if (m_args.trace)
spec->toText(std::cerr);
onSuccess();
}
m_get_plan_stmt->reset();
}
void Animation::downloadFinished(const QByteArray& data) {
// parse the animation/fbx file on a background thread.
AnimationReader* animationReader = new AnimationReader(_url, data);
connect(animationReader, SIGNAL(onSuccess(HFMModel::Pointer)), SLOT(animationParseSuccess(HFMModel::Pointer)));
connect(animationReader, SIGNAL(onError(int, QString)), SLOT(animationParseError(int, QString)));
QThreadPool::globalInstance()->start(animationReader);
}
void IDBRequest::requestCompleted(const IDBResultData& resultData)
{
m_idbError = resultData.error();
if (!m_idbError.isNull())
onError();
else
onSuccess();
}
void Session::onReadDone(const boost::system::error_code& error, size_t bytes_transferred, Callback cb)
{
if (!error) {
onSuccess(cb);
} else {
onError(error, cb);
}
}
int QueryActor::onGetStateSuccess(int id, std::string data) {
Response resp;
resp.id = id;
resp.data = data;
resp.statusCode = Response::StatusCode::SUCCESS;
onSuccess(resp);
}
void CRegFinishDlg::onRemoteContactList(const char *domain)
{
CRegWizard *wiz = (CRegWizard *) GetParent();
this->domain = domain;
onSuccess();
getUdpSession()->logout();
}
void CRegFinishDlg::onSendError(uint32 seq)
{
CRegWizard *wiz = (CRegWizard *) GetParent();
if (!wiz->isFinished)
onTimeout();
else
onSuccess();
}
void Session::onConnectDone(const boost::system::error_code& error, Callback cb)
{
if (!error) {
_response.hdr.flags = 0;
_response.hdr.extra = sizeof("连接成功");
strcpy(_response.content, "连接成功");
onSuccess(cb);
} else {
onError(error, cb);
}
}
void
getDatabaseState(const IMC::PlanDB& req)
{
(void)req;
IMC::PlanDBState* state = new IMC::PlanDBState;
state->plan_size = 0;
state->plan_count = 0;
MD5 md5sum;
IMC::MessageList<PlanDBInformation>* plandbinfo = &state->plans_info;
while (m_plan_iterator_stmt->execute())
{
IMC::PlanDBInformation* pinfo = new IMC::PlanDBInformation;
*m_plan_iterator_stmt >> pinfo->plan_id
>> pinfo->change_time
>> pinfo->change_sid
>> pinfo->change_sname
>> pinfo->md5
>> pinfo->plan_size;
md5sum.update((const uint8_t*)&pinfo->md5[0], 16); // the MD5 of all MD5s ordered by plan_id
state->plan_size += pinfo->plan_size;
state->plan_count++;
if (m_args.trace)
pinfo->toText(std::cerr);
plandbinfo->push_back(*pinfo);
delete pinfo;
}
m_plan_iterator_stmt->reset();
// Finalized MD5 digest
state->md5.resize(16);
md5sum.finalize((uint8_t*)&state->md5[0]);
m_lastchange_query_stmt->execute();
*m_lastchange_query_stmt >> state->change_time
>> state->change_sid
>> state->change_sname;
m_lastchange_query_stmt->reset();
if (m_args.trace)
state->toText(std::cerr);
m_reply.arg.set(*state);
onSuccess();
delete state;
}
//! Get current plan
void
getPlan(void)
{
if (!initMode() && !execMode())
{
onFailure(DTR("no plan is running"));
return;
}
m_reply.arg.set(m_spec);
m_reply.plan_id = m_spec.plan_id;
onSuccess();
}
//! Start a given plan
//! @param[in] plan_id name of the plan to execute
//! @param[in] spec plan specification message if any
//! @param[in] flags plan control flags
//! @return false if previously executing maneuver was not stopped
bool
startPlan(const std::string& plan_id, const IMC::Message* spec, uint16_t flags)
{
bool stopped = stopPlan(true);
changeMode(IMC::PlanControlState::PCS_INITIALIZING,
DTR("plan initializing: ") + plan_id);
if (!loadPlan(plan_id, spec, true))
return stopped;
changeLog(plan_id);
// Flag the plan as starting
if (initMode() || execMode())
{
if (!stopped)
m_plan->planStopped();
m_plan->planStarted();
}
dispatch(m_spec);
if ((flags & IMC::PlanControl::FLG_CALIBRATE) &&
m_args.do_calib)
{
if (!startCalibration())
return stopped;
}
else
{
IMC::PlanManeuver* pman = m_plan->loadStartManeuver();
startManeuver(pman);
if (execMode())
{
onSuccess(m_last_event);
}
else
{
onFailure(m_last_event);
return stopped;
}
}
return true;
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
}
}
void CuttingDialog::startCut(const CutParams& params)
{
if (thread)
{
qDebug() << "Internal error: startCut() called twice.";
return;
}
thread = new CuttingThread(this);
connect(thread, SIGNAL(success()), SLOT(onSuccess()));
connect(thread, SIGNAL(error(QString)), SLOT(onError(QString)));
thread->setParams(params);
thread->start();
}
medSegmentationWorkspace::medSegmentationWorkspace(QWidget * parent /* = NULL */ ) :
medAbstractWorkspace(parent), d(new medSegmentationWorkspacePrivate)
{
d->segmentationToolBox = new medSegmentationSelectorToolBox(parent);
connect(d->segmentationToolBox, SIGNAL(installEventFilterRequest(medViewEventFilter*)),
this, SLOT(addViewEventFilter(medViewEventFilter*)));
connect(d->segmentationToolBox,SIGNAL(success()),this,SLOT(onSuccess()));
// Always have a parent.
if (!parent)
throw (std::runtime_error ("Must have a parent widget"));
this->addToolBox(d->segmentationToolBox);
}
void
storeInDB(const IMC::PlanSpecification* spec)
{
m_plan_info.plan_size = spec->getPayloadSerializationSize();
m_plan_info.plan_id = spec->plan_id;
m_plan_info.change_time = Clock::getSinceEpoch();
m_plan_info.change_sid = spec->getSource();
m_plan_info.change_sname = resolveSystemId(m_plan_info.change_sid);
Database::Blob plan_data(m_plan_info.plan_size);
spec->serializeFields((uint8_t*)&plan_data[0]);
m_plan_info.md5.resize(16);
MD5::compute((uint8_t*)&plan_data[0], m_plan_info.plan_size, (uint8_t*)&m_plan_info.md5[0]);
m_db->beginTransaction();
int count = 0;
try
{
*m_delete_plan_stmt << m_plan_info.plan_id;
m_delete_plan_stmt->execute(&count);
m_delete_plan_stmt->reset();
*m_insert_plan_stmt << m_plan_info.plan_id
<< m_plan_info.change_time
<< m_plan_info.change_sid
<< m_plan_info.change_sname
<< m_plan_info.md5
<< plan_data;
m_insert_plan_stmt->execute();
onChange(m_plan_info.change_time, m_plan_info.change_sid, m_plan_info.change_sname);
}
catch (std::runtime_error& e)
{
onFailure(e.what());
m_db->rollback();
}
m_db->commit();
if (m_args.trace)
m_plan_info.toText(std::cerr);
m_reply.arg.set(m_plan_info);
onSuccess(count ? DTR("OK (updated)") : DTR("OK (new entry)"));
}
void __JSDownloaderDelegator::startDownload()
{
if (auto texture = Director::getInstance()->getTextureCache()->getTextureForKey(_url))
{
onSuccess(texture);
}
else
{
_downloader = std::make_shared<cocos2d::network::Downloader>();
// _downloader->setConnectionTimeout(8);
_downloader->onTaskError = [this](const cocos2d::network::DownloadTask& task,
int errorCode,
int errorCodeInternal,
const std::string& errorStr)
{
this->onError();
};
_downloader->onDataTaskSuccess = [this](const cocos2d::network::DownloadTask& task,
std::vector<unsigned char>& data)
{
Image* img = new (std::nothrow) Image();
Texture2D *tex = nullptr;
do
{
if (false == img->initWithImageData(data.data(), data.size()))
{
break;
}
tex = Director::getInstance()->getTextureCache()->addImage(img, _url);
} while (0);
CC_SAFE_RELEASE(img);
if (tex)
{
this->onSuccess(tex);
}
else
{
this->onError();
}
};
_downloader->createDownloadDataTask(_url);
}
}
MeltedPlaylistDock::MeltedPlaylistDock(QWidget *parent)
: QDockWidget(parent)
, ui(new Ui::MeltedPlaylistDock)
, m_transportControl(new MeltedPlaylist::TransportControl(m_model))
{
ui->setupUi(this);
ui->tableView->setModel(&m_model);
ui->tableView->setDragDropMode(QAbstractItemView::DragDrop);
ui->tableView->setDropIndicatorShown(true);
ui->tableView->setDragDropOverwriteMode(false);
ui->tableView->setAcceptDrops(true);
connect(&m_model, SIGNAL(loaded()), ui->tableView, SLOT(resizeColumnsToContents()));
connect(&m_model, SIGNAL(dropped(QString,int)), this, SLOT(onDropped(QString,int)));
connect(&m_model, SIGNAL(moveClip(int,int)), this, SLOT(onMoveClip(int,int)));
connect(&m_model, SIGNAL(success()), this, SLOT(onSuccess()));
connect(ui->actionAppendCut, SIGNAL(triggered()), this, SLOT(on_addButton_clicked()));
connect(ui->actionRemove, SIGNAL(triggered()), this, SLOT(on_removeButton_clicked()));
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
ASSERT(currentThread() == originThreadID());
// If an Open request was completed after the page has navigated, leaving this request
// with a stopped script execution context, we need to message back to the server so it
// doesn't hang waiting on a database connection or transaction that will never exist.
if (m_contextStopped) {
switch (data.type()) {
case IDBResultType::OpenDatabaseSuccess:
connectionProxy().abortOpenAndUpgradeNeeded(data.databaseConnectionIdentifier(), IDBResourceIdentifier::emptyValue());
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
connectionProxy().abortOpenAndUpgradeNeeded(data.databaseConnectionIdentifier(), data.transactionInfo().identifier());
break;
default:
break;
}
return;
}
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
case IDBResultType::DeleteDatabaseSuccess:
onDeleteDatabaseSuccess(data);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
case IDBResultType::DeleteDatabaseSuccess:
onDeleteDatabaseSuccess(data);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
}
void
clearDatabase(const IMC::PlanDB& req)
{
inProgress();
m_db->beginTransaction();
try
{
m_delete_all_plans_stmt->execute();
onChange(req);
}
catch (std::runtime_error& e)
{
onFailure(e.what());
m_db->rollback();
return;
}
m_db->commit();
onSuccess();
}
void SoundProcessor::run() {
qCDebug(audio) << "Processing sound file" << _url.toDisplayString();
// replace our byte array with the downloaded data
QByteArray rawAudioByteArray = QByteArray(_data);
QString fileName = _url.fileName().toLower();
static const QString WAV_EXTENSION = ".wav";
static const QString RAW_EXTENSION = ".raw";
if (fileName.endsWith(WAV_EXTENSION)) {
QByteArray outputAudioByteArray;
int sampleRate = interpretAsWav(rawAudioByteArray, outputAudioByteArray);
if (sampleRate == 0) {
qCDebug(audio) << "Unsupported WAV file type";
emit onError(300, "Failed to load sound file, reason: unsupported WAV file type");
return;
}
downSample(outputAudioByteArray, sampleRate);
} else if (fileName.endsWith(RAW_EXTENSION)) {
// check if this was a stereo raw file
// since it's raw the only way for us to know that is if the file was called .stereo.raw
if (fileName.toLower().endsWith("stereo.raw")) {
_isStereo = true;
qCDebug(audio) << "Processing sound of" << rawAudioByteArray.size() << "bytes from" << _url << "as stereo audio file.";
}
// Process as 48khz RAW file
downSample(rawAudioByteArray, 48000);
} else {
qCDebug(audio) << "Unknown sound file type";
emit onError(300, "Failed to load sound file, reason: unknown sound file type");
return;
}
emit onSuccess(_data, _isStereo, _isAmbisonic, _duration);
}
void AnimationReader::run() {
DependencyManager::get<StatTracker>()->decrementStat("PendingProcessing");
CounterStat counter("Processing");
PROFILE_RANGE_EX(resource_parse, __FUNCTION__, 0xFF00FF00, 0, { { "url", _url.toString() } });
auto originalPriority = QThread::currentThread()->priority();
if (originalPriority == QThread::InheritPriority) {
originalPriority = QThread::NormalPriority;
}
QThread::currentThread()->setPriority(QThread::LowPriority);
try {
if (_data.isEmpty()) {
throw QString("Reply is NULL ?!");
}
QString urlname = _url.path().toLower();
bool urlValid = true;
urlValid &= !urlname.isEmpty();
urlValid &= !_url.path().isEmpty();
if (urlValid) {
// Parse the FBX directly from the QNetworkReply
HFMModel::Pointer hfmModel;
if (_url.path().toLower().endsWith(".fbx")) {
hfmModel = FBXSerializer().read(_data, QVariantHash(), _url.path());
} else {
QString errorStr("usupported format");
emit onError(299, errorStr);
}
emit onSuccess(hfmModel);
} else {
throw QString("url is invalid");
}
} catch (const QString& error) {
emit onError(299, error);
}
QThread::currentThread()->setPriority(originalPriority);
}
void DownloadFileTransferAPI::threadFct(boost::shared_array<uint8_t> const &adata, size_t &size) {
FBLOG_DEBUG("DownloadFileTransferAPI::threadFct", "this=" << this);
mFileStream.open(mFileStr.c_str(), std::ios_base::out | std::ios_base::binary);
if(mFileStream.fail()) {
FBLOG_DEBUG("UploadFileTransferAPI::start", "Can't open the target file: " << mFileStr);
onError("Can't open the target file");
return;
}
try {
// Write the file by chunck
const char *data = (const char *)adata.get();
size_t writeSize;
while(!boost::this_thread::interruption_requested() && size > 0) {
writeSize = size;
if(writeSize > BUFFER_SIZE) writeSize = BUFFER_SIZE;
mFileStream.write(data, writeSize);
if(mFileStream.fail()) {
FBLOG_DEBUG("DownloadFileTransferAPI::threadFct", "File write error");
onError("File write error");
throw std::runtime_error("File write error");
}
data += writeSize;
size -= writeSize;
}
mFileStream.close();
onSuccess(true);
} catch(std::runtime_error&) {
// Remove incomplete file
mFileStream.close();
boost::filesystem::remove(mFilePath);
}
detachThread(boost::this_thread::get_id());
mThread.reset();
}
//! Load a plan into the vehicle
//! @param[in] plan_id name of the plan
//! @param[in] arg argument which may either be a maneuver or a plan specification
//! @param[in] plan_startup true if a plan will start right after
//! @return true if plan is successfully loaded
bool
loadPlan(const std::string& plan_id, const IMC::Message* arg,
bool plan_startup = false)
{
if ((initMode() && !plan_startup) || execMode())
{
onFailure(DTR("cannot load plan now"));
return false;
}
std::string info;
if (!parseArg(plan_id, arg, info))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan load failed: ") + info);
return false;
}
IMC::PlanStatistics ps;
if (!parsePlan(plan_startup, ps))
{
changeMode(IMC::PlanControlState::PCS_READY,
DTR("plan parse failed: ") + m_reply.info);
return false;
}
// reply with statistics
m_reply.arg.set(ps);
m_reply.plan_id = m_spec.plan_id;
m_pcs.plan_id = m_spec.plan_id;
onSuccess(DTR("plan loaded"), false);
return true;
}
