Response::~Response() {
LOGV(LOG_LEVEL_RESPONSE, 0, LOG_FORMAT(), __PRETTY_FUNCTION__, __LINE__);
for (unsigned char i = 0; i < TEXIDX_BUFFER_SIZE; ++i)
if (mTexIdx[i] != 0)
mTextures->delTexture(mTexIdx[i]);
}
//Interface for UI
//receive a index and url, create a IRDownloadRequest and append it to mReqMap
//then, schedule the downloading
bool IRParallelDownloadSession::addRequest(const int &aIndex,const QString &aUrl)
{
LOG_METHOD;
Qt::HANDLE threadid = QThread::currentThreadId();
LOG_FORMAT(" !!!thread IRParallelDownloadSession::addRequest id=%d",(int)threadid);
mMutex->lock();
bool ret = true;
if(KRquestCountMax > mReqMap.count())
{
//construct request object according to input parameter
IRDownloadRequest *request = new IRDownloadRequest(aIndex,aUrl,this);
request->moveToThread(this->thread());//in order to let onRequestFinished() run in sub thread
//append just creaded request to mReqMap
//This is not QList shouldn't use append();
mReqMap.insert(aIndex, request);
}
else
{
ret = false;
}
mMutex->unlock();
return ret;
// can not scheduleReqForDownloading() now, shedule it in startSchedule().
}
void IRNowPlayingView::updateSongName(const QString &aSongName)
{
LOG_METHOD;
iSongNameMarquee->stopAnimation();
iSongNameLabel->hide();
iSongNameMarquee->hide();
iSongNameLabel->setPlainText(aSongName);
iSongNameMarquee->setText(aSongName);
QFontMetricsF metrics(iSongNameLabel->font());
LOG_FORMAT("song name = %s, song name length = %f, label width = %f",
STRING2CHAR(aSongName),
metrics.boundingRect(aSongName).width(),
iSongNameLabel->contentsRect().width()
);
if (metrics.boundingRect(aSongName).width() > iSongNameLabel->contentsRect().width())
{
iSongNameMarquee->show();
iSongNameMarquee->startAnimation();
}
else
{
iSongNameLabel->show();
}
}
void Response::start() {
LOGV(LOG_LEVEL_RESPONSE, 0, LOG_FORMAT(), __PRETTY_FUNCTION__, __LINE__);
std::memcpy(mTransform, Object2D::TransformBuffer, sizeof(float) * TRANSFORM_BUFFER_SIZE);
// Make a correction on indices (that start from -50°)
rotate(ROTATION_CORRECTION); // => -2.5° for texture coordinates correction (that start from -2.5°)
}
void IrHsWidgetTitleRow::setStationName(const QString& aStationName)
{
LOG_METHOD;
LOG_FORMAT("aStationName = %s", STRING2CHAR(aStationName));
if (mStationName->plainText() != aStationName)
{
mStationName->setPlainText(aStationName);
}
}
Response::Response() : Sphere(false), mToRender(false), mToDisplay(0), mCancel(false), mForce(false), mScale(0.f),
mOrientation(0), mRotateVel(0.f), mRotation(0.f) {
LOGV(LOG_LEVEL_RESPONSE, 0, LOG_FORMAT(), __PRETTY_FUNCTION__, __LINE__);
std::memset(mTexIdx, 0, TEXIDX_BUFFER_SIZE);
std::memset(&mCurAccel, 0, sizeof(AccelData));
mFullTexCoords = mTexCoords;
}
FeedObject* MRFeedListModel::data(const int row) const
{
LOG_METHOD;
FeedObject *dobj = m_items.at(row);
LOG_FORMAT("%s",dobj->type.toLatin1().data());
return dobj;
}
//aIndexs need Traversall from start to end, so use foreach
void IRParallelDownloadSession::removeRequest(const QList<int> &aIndexList)
{
LOG_METHOD;
Qt::HANDLE threadid = QThread::currentThreadId();
LOG_FORMAT(" !!!thread IRParallelDownloadSession::removeRequest_QList id=%d",(int)threadid);
//NonRecursive Lock. locked in removeRequest(inputIndex), mMutex.lock() is not necessary here.
//foreach is OK here. loop index by aIndexList, but the removed container is mReqMap. It's Safe!!
foreach (int inputIndex, aIndexList)
{
removeRequest(inputIndex);
}
//Implementation
IRParallelDownloadSession::IRParallelDownloadSession()
:mMaxActiveCount(0),
mActiveCount(0),
mStarted(false),
mThread(NULL),
mPendingRequest(false)
{
Qt::HANDLE threadid = QThread::currentThreadId();
LOG_FORMAT(" !!!thread IRParallelDownloadSession::IRParallelDownloadSession id=%d",(int)threadid);
mMutex = new QMutex(QMutex::NonRecursive);
mNwkAccessMgr = NULL;
}
void Response::load(unsigned char responseId) {
LOGV(LOG_LEVEL_RESPONSE, 0, LOG_FORMAT(" - r:%d"), __PRETTY_FUNCTION__, __LINE__, responseId);
switch (responseId) {
case RESPONSE_ID_TITLE: mTexIdx[0] = Textures::loadTexture(TEXTURE_ID_TITLE); break;
case RESPONSE_ID_AVAILABLE: mTexIdx[1] = Textures::loadTexture(TEXTURE_ID_AVAILABLE); break;
case RESPONSE_ID_STORES: mTexIdx[2] = Textures::loadTexture(TEXTURE_ID_STORES); break;
#ifdef DEBUG
default: {
LOGW(LOG_FORMAT(" - Unknown response item to load (%d)"), __PRETTY_FUNCTION__, __LINE__, responseId);
assert(NULL);
return;
}
#endif
}
assert(mTexIdx[responseId] != 0);
mTextures->genTexture(mTexIdx[responseId]);
if (mToDisplay == responseId) // Needed when resume
mTextureIdx = mTexIdx[responseId];
}
/********************************************************************************************************
* SLOT for Network Event
*******************************************************************************************************
*/
void IRNowPlayingView::handleNetworkEvent(IRQNetworkEvent aEvent)
{
LOG_METHOD;
LOG_FORMAT("aEvent = %d", (int)aEvent );
if( this != getViewManager()->currentView() )
{
return;
}
switch(aEvent)
{
case EIRQNetworkConnectionEstablished:
{
if( EIR_UseNetwork_StartingView == getUseNetworkReason() )
{
IRPlayList *playList = iApplication->getPlayList();
if (playList && 1 == playList->getNumberOfEntries())
{
IRQPreset *preset = playList->getPresetForEntry(0);
iPlayController->connectToChannel(preset, EIRQAdhocExternal);
delete preset;
}
else
{
IRLastPlayedStationInfo *lastPlayedStationInfo = iApplication->getLastPlayedStationInfo();
if( lastPlayedStationInfo )
{
IRQPreset *lastPreset = NULL;
lastPreset = lastPlayedStationInfo->getLastPlayedStation();
if (lastPreset)
{
iPlayController->connectToChannel( lastPreset, lastPlayedStationInfo->connectedFrom() );
}
}
}
}
else if( EIR_UseNetwork_PlayStation == getUseNetworkReason() )
{
iPlayController->resume();
}
break;
}
default:
break;
}
setUseNetworkReason(EIR_UseNetwork_NoReason);
}
MRFeedListModel::MRFeedListModel(const QString& foldername, QObject *parent) :
QAbstractListModel(parent), mFolderName(foldername)
{
LOG_METHOD;
LOG_FORMAT("MRFeedListModel constuct folder name:%s", mFolderName.toLatin1().data());
QHash<int, QByteArray> roles;
roles[ETitle] = "title";
roles[EType] = "type";
roles[EUrl] = "url";
roles[EIconUrl] = "iconUrl";
roles[EHtmlUrl] = "htmlUrl";
roles[EDescription] = "description";
roles[ESubscribed] = "subscribed";
roles[ELocalPath] = "localpath";
setRoleNames(roles);
}
static VC_CONTAINER_STATUS_T ps_read_system_header( VC_CONTAINER_T *ctx )
{
uint8_t header[8];
uint32_t length;
VC_CONTAINER_BITS_T bits;
if(_READ_U32(ctx) != 0x1BB) return VC_CONTAINER_ERROR_CORRUPTED;
LOG_FORMAT(ctx, "system_header");
ctx->priv->module->level++;
length = READ_U16(ctx, "header_length");
if(length < 6) return VC_CONTAINER_ERROR_CORRUPTED;
if(READ_BYTES(ctx, header, 6) != 6) return VC_CONTAINER_ERROR_EOS;
BITS_INIT(ctx, &bits, header, 6);
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
BITS_SKIP(ctx, &bits, 22, "rate_bound");
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
BITS_SKIP(ctx, &bits, 6, "audio_bound");
BITS_SKIP(ctx, &bits, 1, "fixed_flag");
BITS_SKIP(ctx, &bits, 1, "CSPS_flag");
BITS_SKIP(ctx, &bits, 1, "system_audio_lock_flag");
BITS_SKIP(ctx, &bits, 1, "system_video_lock_flag");
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
BITS_SKIP(ctx, &bits, 5, "video_bound");
BITS_SKIP(ctx, &bits, 1, "packet_rate_restriction_flag");
BITS_SKIP(ctx, &bits, 7, "reserved_bits");
length -= 6;
while(length >= 3 && (PEEK_U8(ctx) & 0x80))
{
SKIP_U8(ctx, "stream_id");
SKIP_BYTES(ctx, 2);
length -= 3;
}
SKIP_BYTES(ctx, length);
ctx->priv->module->level--;
return STREAM_STATUS(ctx);
}
QString MRFeedListModel::data(const int row, int role) const
{
FeedObject *dobj = m_items.at(row);
QString result = QString();
switch (role) {
case Qt::DisplayRole: // The default display role now displays the first name as well
case ETitle:
result = dobj->title;
break;
case EType:
result = dobj->type;
break;
case EUrl:
result = dobj->url;
break;
case EIconUrl:
result = dobj->iconUrl;
break;
case EHtmlUrl:
result = dobj->htmlUrl;
break;
case EDescription:
result = dobj->description;
break;
case ESubscribed:
result = dobj->subscribed;
break;
case ELocalPath:
result = dobj->urlLocalPath;
break;
default:
result = QString();
}
LOG_FORMAT("FeedListModel data:%s, row:%d, role:%d", result.toLatin1().data(), row, role);
return result;
}
/*
* Description : from base class IRBaseView.
* handle view commands.
* Parameters : aCommand : see the definition of TIRViewCommand
* Return : EIR_DoDefault : caller does default handling
* EIR_NoDefault : caller doesn't do default handling
*/
TIRHandleResult IRNowPlayingView::handleCommand(TIRViewCommand aCommand, TIRViewCommandReason aReason)
{
LOG_METHOD;
LOG_FORMAT("aCommand = %d", (int)aCommand);
Q_UNUSED(aReason);
TIRHandleResult ret = EIR_DoDefault;
switch (aCommand)
{
case EIR_ViewCommand_TOBEACTIVATED:
handleOrientationChanged(getViewManager()->orientation());
updateMusicStoreStatus();
updateWidgets();
ret = EIR_NoDefault;
break;
case EIR_ViewCommand_ACTIVATED:
connect(iIsdsClient, SIGNAL(presetLogoDownloaded(IRQPreset* )),
this, SLOT(handleLogoDownloaded(IRQPreset* )));
updateStationLogo();
getViewManager()->saveScreenShot();
break;
case EIR_ViewCommand_DEACTIVATE:
if( iLogoDownloadState != EIdle )
{
// cancel downloading logo
iIsdsClient->isdsLogoDownCancelTransaction();
iLogoDownloadState = EIdle;
}
disconnect(iIsdsClient, SIGNAL(presetLogoDownloaded(IRQPreset*)),
this, SLOT(handleLogoDownloaded(IRQPreset* )));
ret = EIR_NoDefault;
break;
}
return ret;
}
static VC_CONTAINER_STATUS_T ps_read_pack_header( VC_CONTAINER_T *ctx )
{
VC_CONTAINER_MODULE_T *module = ctx->priv->module;
uint8_t header[10];
int64_t scr, scr_base, scr_ext = INT64_C(0);
uint64_t pack_offset = STREAM_POSITION(ctx);
uint32_t mux_rate, stuffing;
VC_CONTAINER_BITS_T bits;
VC_CONTAINER_STATUS_T status;
if(_READ_U32(ctx) != 0x1BA) return VC_CONTAINER_ERROR_CORRUPTED;
LOG_FORMAT(ctx, "pack_header");
module->level++;
if (PEEK_U8(ctx) & 0x40) /* program stream */
{
if(READ_BYTES(ctx, header, 10) != 10) return VC_CONTAINER_ERROR_EOS;
BITS_INIT(ctx, &bits, header, 10);
if(BITS_READ_U32(ctx, &bits, 2, "'01' marker bits") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base = BITS_READ_U32(ctx, &bits, 3, "system_clock_reference_base [32..30]") << 30;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [29..15]") << 15;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [14..0]");
LOG_FORMAT(ctx, "system_clock_reference_base %"PRId64, scr_base);
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_ext = BITS_READ_U32(ctx, &bits, 9, "system_clock_reference_extension");
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
mux_rate = BITS_READ_U32(ctx, &bits, 22, "program_mux_rate");
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
BITS_SKIP(ctx, &bits, 5, "reserved");
stuffing = BITS_READ_U32(ctx, &bits, 3, "pack_stuffing_length");
SKIP_BYTES(ctx, stuffing);
}
else /* system stream */
{
if(READ_BYTES(ctx, header, 8) != 8) return VC_CONTAINER_ERROR_EOS;
BITS_INIT(ctx, &bits, header, 8);
if(BITS_READ_U32(ctx, &bits, 4, "'0010' marker bits") != 0x2) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base = BITS_READ_U32(ctx, &bits, 3, "system_clock_reference_base [32..30]") << 30;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [29..15]") << 15;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
scr_base |= BITS_READ_U32(ctx, &bits, 15, "system_clock_reference_base [14..0]");
LOG_FORMAT(ctx, "system_clock_reference_base %"PRId64, scr_base);
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
mux_rate = BITS_READ_U32(ctx, &bits, 22, "program_mux_rate");
if(BITS_READ_U32(ctx, &bits, 1, "marker_bit") != 0x1) return VC_CONTAINER_ERROR_CORRUPTED;
}
if ((status = STREAM_STATUS(ctx)) != VC_CONTAINER_SUCCESS) return status;
module->level--;
/* Set or update system_clock_reference, adjust bias if necessary */
scr = scr_base * INT64_C(300) + scr_ext;
if (module->scr_offset == VC_CONTAINER_TIME_UNKNOWN)
module->scr_offset = scr;
if (module->scr == VC_CONTAINER_TIME_UNKNOWN)
module->scr_bias = -scr;
else if (scr < module->scr)
module->scr_bias = module->scr - scr;
if (module->scr != VC_CONTAINER_TIME_UNKNOWN)
{
/* system_clock_reference is not necessarily continuous across the entire stream */
if (scr > module->scr)
{
int64_t data_rate;
data_rate = INT64_C(27000000) * (pack_offset - module->pack_offset) / (scr - module->scr);
if (module->data_rate)
{
/* Simple moving average over data rate seen so far */
module->data_rate = (module->data_rate * 31 + data_rate) >> 5;
}
else
{
void Response::update(const Game* game, const Level* level) {
#ifdef DEBUG
LOGV(LOG_LEVEL_RESPONSE, (*game->getLog() % 100), LOG_FORMAT(" - g:%x; l:%x (r:%s)"), __PRETTY_FUNCTION__, __LINE__, game,
level, (mToRender)? "true":"false");
#endif
if (!mToRender)
return;
// Rotation according device position
if (game->mAccelData) {
#ifdef __ANDROID__
#ifdef DEBUG
const Input* accelInput = Inputs::getInstance()->get(Inputs::ACCEL);
assert((*static_cast<const float*>(accelInput->getConfig())) < ((ACCEL_LIMITS_SUP * 2.f) + 1.f));
assert((*static_cast<const float*>(accelInput->getConfig())) > ((ACCEL_LIMITS_SUP * 2.f) - 1.f));
#endif
float x = ACCEL_CLIP(game->mAccelData->X);
float y = ACCEL_CLIP(game->mAccelData->Y);
float z = ACCEL_CLIP(game->mAccelData->Z);
#else
// No maximum accelerometer value available on iOS
// -> Using a common range of [-11;11] values (after having * 10)
float x = ACCEL_CLIP(-game->mAccelData->X * 10.f);
float y = ACCEL_CLIP(-game->mAccelData->Y * 10.f);
float z = ACCEL_CLIP(-game->mAccelData->Z * 10.f);
#endif
unsigned char orientation = 0;
if ((ORIENTATION_INF < z) && (z < ORIENTATION_SUP)) {
if ((ORIENTATION_INF < x) && (x < ORIENTATION_SUP)) orientation = (ORIENTATION_SUP < y)? PORTRAIT:REV_PORTRAIT;
else if ((ORIENTATION_INF < y) && (y < ORIENTATION_SUP)) orientation = (ORIENTATION_SUP < x)? LANDSCAPE:REV_LANDSCAPE;
}
if ((!orientation) && (ORIENTATION_INF < x) && (x < ORIENTATION_SUP) &&
(ORIENTATION_INF < y) && (y < ORIENTATION_SUP)) orientation = (ORIENTATION_SUP < z)? FLAT:REVERSED;
unsigned char prevOrientation = mOrientation;
if (orientation)
mOrientation = orientation;
switch (mOrientation) {
default: {
mOrientation = PORTRAIT;
//break;
}
case PORTRAIT: { // Portrait (home button at bottom)
if (prevOrientation == LANDSCAPE) {
mRotation -= (2.f * PI_F);
mRotateVel -= (2.f * PI_F);
}
else if (ACCEL_CHANGED(mCurAccel.X, x))
mRotateVel = x * ACCEL_TO_ROTATION;
break;
}
case REV_PORTRAIT: { // Reversed portrait
if (ACCEL_CHANGED(mCurAccel.X, x))
mRotateVel = (x * -ACCEL_TO_ROTATION) + PI_F;
break;
}
case LANDSCAPE: { // Landscape (home button at right)
if (prevOrientation == PORTRAIT) {
mRotation += (2.f * PI_F);
mRotateVel += (2.f * PI_F);
}
else if (ACCEL_CHANGED(mCurAccel.Y, y))
mRotateVel = (y * -ACCEL_TO_ROTATION) + ((3.f * PI_F) / 2.f);
break;
}
case REV_LANDSCAPE: { // Reversed landscape
if (ACCEL_CHANGED(mCurAccel.Y, y))
mRotateVel = (y * ACCEL_TO_ROTATION) + (PI_F / 2.f);
break;
}
case FLAT: // Flat
case REVERSED: { // Reversed
if ((!ACCEL_CHANGED(mCurAccel.X, x)) && (!ACCEL_CHANGED(mCurAccel.Y, y)))
break;
static unsigned char prevPos = 0;
if ((y > 0.f) && (x < 0.f)) {
mRotateVel = std::atan(-x / y);
prevPos = 0;
}
else if ((y < 0.f) && (x < 0.f)) {
mRotateVel = std::atan(y / x) + (PI_F / 2.f);
prevPos = 0;
}
else if ((y < 0.f) && (x > 0.f)) {
if (prevPos == 2)
mRotation += (2.f * PI_F);
mRotateVel = PI_F - std::atan(x / y);
prevPos = 1;
}
else if ((y > 0.f) && (x > 0.f)) { // 'else if' instead of 'else' coz 'y' must be > 0
if (prevPos == 1)
mRotation -= (2.f * PI_F);
mRotateVel = -std::atan(x / y);
prevPos = 2;
}
//else // 'x' & 'y' are equal to 0: Nothing to do
break;
}
}
if (ACCEL_CHANGED(mCurAccel.X, x)) mCurAccel.X = x;
if (ACCEL_CHANGED(mCurAccel.Y, y)) mCurAccel.Y = y;
if (ACCEL_CHANGED(mCurAccel.Z, z)) mCurAccel.Z = z;
mRotation = mRotation - ((mRotation - mRotateVel) / VELOCITY);
rotate(ROTATION_CORRECTION + mRotation);
}
// Hide & Display response
if (mCancel) {
if (getAlpha() < ALPHA_VEL_A) {
mToDisplay = 0;
mToRender = false;
mCancel = false;
mForce = false;
}
else
setAlpha(getAlpha() - (ALPHA_VEL_A * game->getDelta() / DELTA_REF));
if (mScale < MAX_SCALE) {
mScale += (SCALE_VELOCITY * game->getDelta() / DELTA_REF);
scale(mScale, mScale);
}
return;
}
if (mForce) {
mScale = MAX_SCALE;
//setAlpha(MAX_ALPHA); // Let caller manage this
scale(MAX_SCALE, MAX_SCALE);
return;
}
if (getAlpha() < ((mToDisplay == RESPONSE_ID_STORES)? 1.f:MAX_ALPHA)) {
setAlpha(getAlpha() + (ALPHA_VEL_A * game->getDelta() / DELTA_REF));
if (mScale < MAX_SCALE) {
mScale += (SCALE_VELOCITY * game->getDelta() / DELTA_REF);
scale(mScale, mScale);
}
}
}
