--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qtinternetradio/irhswidgetplugin/src/irserviceclient.cpp Wed Jun 23 18:04:00 2010 +0300
@@ -0,0 +1,507 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: internet radio hs widget service client
+*
+*/
+
+// System includes
+#include <QSettings>
+#include <QVariant>
+#include <QString>
+#include <hbicon.h>
+#include <xqserviceglobal.h>
+#include <xqservicerequest.h>
+
+
+// User includes
+#include "irserviceclient.h"
+#include "irservicedata.h"
+
+// Constants
+// For services via Qt HighWay
+static const QString KIrServiceName = "internet_radio_10_1";
+static const QString KIrServiceControlInterfaceName = "com.nokia.symbian.IInternetRadioControl";
+static const QString KIrServiceControlOperation = "handleCmd(int)";
+static const QString KIrServiceMonitorInterfaceName = "com.nokia.symbian.IInternetRadioMonitor";
+static const QString KIrServiceMonitorOperation = "registerNotifications()";
+static const QString KIrServiceRefreshOperation = "refreshAllData()";
+
+// ==================== MEMBER FUNCTIONS ======================
+// Constructor
+IrServiceClient::IrServiceClient(QObject *aParent) :
+ QObject(aParent),
+ mIrAppInspector(NULL),
+ mMonitorReqOngoing(false),
+ mControlReqOngoing(false),
+ mMonitorRequest(NULL),
+ mRefreshRequest(NULL),
+ mControlRequest(NULL)
+{
+ mIrAppInspector = new IrAppInspector(this);
+
+ QObject::connect(mIrAppInspector, SIGNAL(irRunningStatusChanged(IrAppInspector::IrRunningStatus)),
+ this, SLOT(handleIrRunningStatusChanged(IrAppInspector::IrRunningStatus)));
+}
+
+// Destructor
+IrServiceClient::~IrServiceClient()
+{
+ delete mMonitorRequest;
+ mMonitorRequest = NULL;
+
+ delete mRefreshRequest;
+ mRefreshRequest = NULL;
+
+ delete mControlRequest;
+ mControlRequest = NULL;
+}
+
+bool IrServiceClient::startMonitoringIrState()
+{
+ bool retVal = false;
+ if (mIrAppInspector->isIrRunning())
+ {
+ retVal = doSendRefreshRequest();
+ }
+ else
+ {
+ if (isStationPlayed())
+ {
+ initHsWidgetNoRunStopped();
+ }
+ else
+ {
+ emit irStateChanged(IrAppState::NoRunInit);
+ }
+ }
+
+ return mIrAppInspector->startInspectingIrRunningStatus() && retVal;
+}
+
+void IrServiceClient::stopMonitoringIrState()
+{
+ delete mMonitorRequest;
+ mMonitorRequest = NULL;
+
+ delete mRefreshRequest;
+ mRefreshRequest = NULL;
+}
+
+void IrServiceClient::initHsWidgetNoRunStopped()
+{
+ emit irStateChanged(IrAppState::NoRunStopped);
+
+ QString stationName;
+ if (loadStationName(stationName))
+ {
+ emit stationNameUpdated(stationName);
+ }
+ else
+ {
+ emit stationNameUpdated(QString(""));
+ }
+
+ emit stationLogoUpdated(loadStationLogoFlag());
+}
+
+/******************************************************************
+**************** Monitor Service Request **********************
+*******************************************************************/
+bool IrServiceClient::doSendMonitorRequest()
+{
+ if(mMonitorReqOngoing)
+ {
+ return false;
+ }
+
+ if (NULL == mMonitorRequest
+ &&!createMonitorServiceRequest())
+ {
+ return false;
+ }
+
+ prepareRequestInfo(mMonitorRequest, DoNotChange);
+ return mMonitorRequest->send();
+}
+
+bool IrServiceClient::createMonitorServiceRequest()
+{
+ bool retVal = false;
+
+ if (NULL == mMonitorRequest)
+ {
+ mMonitorRequest = mApplicationManager.create(KIrServiceName,
+ KIrServiceMonitorInterfaceName,
+ KIrServiceMonitorOperation,
+ false);
+
+ if (mMonitorRequest)
+ {
+ retVal = true;
+
+ connect(mMonitorRequest, SIGNAL(requestOk(const QVariant&)),
+ this, SLOT(handleMonitorRequestOk(const QVariant&)));
+ connect(mMonitorRequest, SIGNAL(requestError(int,const QString&)),
+ this, SLOT(handleMonitorRequestError(int,const QString&)));
+
+ mMonitorRequest->setEmbedded(false);
+ mMonitorRequest->setSynchronous(false);
+ }
+ }
+ else
+ {
+ retVal = true;
+ }
+
+ return retVal;
+}
+
+// ==================== Refresh Service Request ===========================
+bool IrServiceClient::doSendRefreshRequest()
+{
+ if(mMonitorReqOngoing)
+ {
+ return false;
+ }
+
+ if (NULL == mRefreshRequest
+ && !createRefreshServiceRequest())
+ {
+ return false;
+ }
+
+ prepareRequestInfo(mRefreshRequest, DoNotChange);
+ return mRefreshRequest->send();
+}
+
+bool IrServiceClient::createRefreshServiceRequest()
+{
+ bool retVal = false;
+
+ if (NULL == mRefreshRequest)
+ {
+ mRefreshRequest = mApplicationManager.create(KIrServiceName,
+ KIrServiceMonitorInterfaceName,
+ KIrServiceRefreshOperation,
+ false);
+
+ if (mRefreshRequest)
+ {
+ retVal = true;
+
+ connect(mRefreshRequest, SIGNAL(requestOk(const QVariant&)),
+ this, SLOT(handleMonitorRequestOk(const QVariant&)));
+ connect(mRefreshRequest, SIGNAL(requestError(int,const QString&)),
+ this, SLOT(handleMonitorRequestError(int,const QString&)));
+
+ mRefreshRequest->setEmbedded(false);
+ mRefreshRequest->setSynchronous(false);
+ }
+ }
+ else
+ {
+ retVal = true;
+ }
+
+ return retVal;
+}
+
+void IrServiceClient::handleMonitorRequestOk(const QVariant &aRetValue)
+{
+ mMonitorReqOngoing = false;
+
+ doSendMonitorRequest();
+
+ if (aRetValue.isValid()
+ && aRetValue.canConvert(QVariant::List))
+ {
+ QVariantList dataList = aRetValue.toList();
+ foreach (const QVariant& data, dataList)
+ {
+ if (data.canConvert<IrServiceData>())
+ {
+ IrServiceData serviceData = data.value<IrServiceData>();
+ processNotificationData(serviceData);
+ }
+ }
+ }
+}
+
+void IrServiceClient::handleMonitorRequestError(int aErrCode, const QString &aErrMessage)
+{
+ mMonitorReqOngoing = false;
+
+ Q_UNUSED(aErrCode);
+ Q_UNUSED(aErrMessage);
+}
+
+/******************************************************************
+**************** Control Service Request **********************
+*******************************************************************/
+bool IrServiceClient::bringIrForeground()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::Foreground);
+ return doSendControlRequest(commandArgument, true, ToForeground);
+}
+
+bool IrServiceClient::launchIrNormally()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::LaunchNormally);
+ return doSendControlRequest(commandArgument, true, ToForeground);
+}
+
+bool IrServiceClient::launchIrNowPlaying()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::LaunchNowPlayingView);
+ return doSendControlRequest(commandArgument, false, ToBackground);
+}
+
+
+bool IrServiceClient::startPlaying()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::Play);
+ return doSendControlRequest(commandArgument, true, DoNotChange);
+}
+
+
+bool IrServiceClient::stopPlaying()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::Stop);
+ return doSendControlRequest(commandArgument, true, DoNotChange);
+}
+
+bool IrServiceClient::cancelLoading()
+{
+ QVariant commandArgument(QVariant::Int);
+ commandArgument.setValue((int)IrServiceCmd::Cancel);
+ return doSendControlRequest(commandArgument, true, DoNotChange);
+}
+
+bool IrServiceClient::doSendControlRequest(const QVariant &aArgument, bool aIsSync, IrAppVisibilty aVisibility)
+{
+ if(mControlReqOngoing)
+ {
+ return false;
+ }
+
+ if (NULL == mControlRequest &&
+ !createControlServiceRequest())
+ {
+ return false;
+ }
+
+ QList<QVariant> arguments;
+ arguments.append(aArgument);
+ mControlRequest->setArguments(arguments);
+
+ prepareRequestInfo(mControlRequest, aVisibility);
+ mControlRequest->setSynchronous(aIsSync);
+ return mControlRequest->send();
+}
+
+bool IrServiceClient::createControlServiceRequest()
+{
+ bool retVal = false;
+
+ if (NULL == mControlRequest)
+ {
+ mControlRequest = mApplicationManager.create(KIrServiceName,
+ KIrServiceControlInterfaceName,
+ KIrServiceControlOperation,
+ false);
+
+ if (mControlRequest)
+ {
+ retVal = true;
+
+ connect(mControlRequest, SIGNAL(requestOk(const QVariant&)),
+ this, SLOT(handleControlRequestOk(const QVariant&)));
+ connect(mControlRequest, SIGNAL(requestError(int,const QString&)),
+ this, SLOT(handleControlRequestError(int,const QString&)));
+
+ mControlRequest->setEmbedded(false);
+ }
+ }
+ else
+ {
+ retVal = true;
+ }
+
+ return retVal;
+}
+
+void IrServiceClient::handleControlRequestOk(const QVariant &aRetValue)
+{
+ mControlReqOngoing = false;
+
+ if (aRetValue.isValid()
+ && aRetValue.canConvert(QVariant::Int))
+ {
+ if (IrServiceResult::Fail == aRetValue.toInt())
+ {
+ emit controlFailed();
+ }
+ }
+}
+
+void IrServiceClient::handleControlRequestError(int aErrCode, const QString &aErrMessage)
+{
+ mControlReqOngoing = false;
+
+ emit controlFailed();
+
+ Q_UNUSED(aErrCode);
+ Q_UNUSED(aErrMessage);
+}
+/******************************************************************
+************************* Others ******************************
+*******************************************************************/
+// slot connected to signals from IrAppInspector,
+// used to monitor the startup / exit of IR
+void IrServiceClient::handleIrRunningStatusChanged(IrAppInspector::IrRunningStatus aNewStatus)
+{
+ switch (aNewStatus)
+ {
+ case IrAppInspector::StartingUp :
+ doSendRefreshRequest();
+ break;
+
+ case IrAppInspector::Exiting :
+ stopMonitoringIrState();
+
+ if (isStationPlayed())
+ {
+ resetHsWidgetExitStopped();
+ }
+ else
+ {
+ emit irStateChanged(IrAppState::NoRunInit);
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void IrServiceClient::resetHsWidgetExitStopped()
+{
+ emit irStateChanged(IrAppState::NoRunStopped);
+ emit metaDataUpdated(QString(""));
+}
+
+// used to process service data sent from IR app.
+void IrServiceClient::processNotificationData(const IrServiceData &aServiceData)
+{
+ QVariant data = aServiceData.mData;
+ if (!data.isValid())
+ {
+ return;
+ }
+ switch (aServiceData.mType)
+ {
+ case IrServiceNotification::StationName:
+ if (data.canConvert(QVariant::String))
+ {
+ emit stationNameUpdated(data.toString());
+ }
+ break;
+
+ case IrServiceNotification::MetaData:
+ if (data.canConvert(QVariant::String))
+ {
+ emit metaDataUpdated(data.toString());
+ }
+ break;
+
+ case IrServiceNotification::StationLogo:
+ if (data.canConvert(QVariant::Bool))
+ {
+ emit stationLogoUpdated(data.toBool());
+ }
+ break;
+
+ case IrServiceNotification::IrState:
+ if (data.canConvert(QVariant::Int))
+ {
+ emit irStateChanged((IrAppState::Type)data.toInt());
+ }
+ break;
+
+ default:
+ break;
+ }
+
+}
+
+// prepare the request send to IR app, including control request, refresh request, monitor request.
+void IrServiceClient::prepareRequestInfo(XQAiwRequest *aRequest, IrAppVisibilty aVisibility)
+{
+ if (NULL == aRequest)
+ {
+ return;
+ }
+
+ XQRequestInfo reqInfo;
+ switch (aVisibility)
+ {
+ case ToForeground:
+ reqInfo.setForeground(true);
+ break;
+ case ToBackground:
+ reqInfo.setBackground(true);
+ break;
+ case DoNotChange:
+ break;
+ default:
+ break;
+ }
+
+ aRequest->setInfo(reqInfo);
+}
+
+bool IrServiceClient::isStationPlayed()
+{
+ QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);
+ QString stationName = settings.value(KIrSettingStationName,KIrDefaultStationName).toString();
+ return stationName != KIrDefaultStationName;
+}
+
+bool IrServiceClient::loadStationLogoFlag()
+{
+ QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);
+ return settings.value(KIrSettingStationLogoAvailable,false).toBool();
+}
+
+bool IrServiceClient::loadStationName(QString &aStationName)
+{
+ QSettings settings(KIrSettingOrganization, KIrSettingApplicaton);
+ aStationName = settings.value(KIrSettingStationName,KIrDefaultStationName).toString();
+ if(aStationName != KIrDefaultStationName)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+Q_IMPLEMENT_USER_METATYPE(IrServiceData)
+