diff -r 000000000000 -r 876b1a06bc25 plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugins/multimedia/symbian/mmf/radio/s60radiotunercontrol_since32.cpp Wed Aug 25 15:49:42 2010 +0300 @@ -0,0 +1,472 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt Mobility Components. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "s60radiotunercontrol_since32.h" +#include "s60radiotunerservice.h" + +#include +#include + +S60RadioTunerControl::S60RadioTunerControl(QObject *parent) + : QRadioTunerControl(parent) + , m_error(0) + , m_radioUtility(NULL) + , m_fmTunerUtility(NULL) + , m_playerUtility(NULL) + , m_audioInitializationComplete(false) + , m_muted(false) + , m_isStereo(true) + , m_vol(100) + , m_signal(0) + , m_radioError(QRadioTuner::NoError) + , m_scanning(false) + , m_currentBand(QRadioTuner::FM) + , m_currentFreq(87500000) + , m_stereoMode(QRadioTuner::Auto) + , m_apiTunerState(QRadioTuner::StoppedState) + , m_maxVolume(100) +{ + initRadio(); +} + +S60RadioTunerControl::~S60RadioTunerControl() +{ + if (m_fmTunerUtility) { + m_fmTunerUtility->Close(); + } + + if(m_playerUtility) { + m_playerUtility->Close(); + } + + delete m_radioUtility; +} + +QRadioTuner::State S60RadioTunerControl::state() const +{ + return m_apiTunerState; +} + +QRadioTuner::Band S60RadioTunerControl::band() const +{ + return m_currentBand; +} + +bool S60RadioTunerControl::isBandSupported(QRadioTuner::Band b) const +{ + if(b == QRadioTuner::FM) + return true; + else if(b == QRadioTuner::LW) + return false; + else if(b == QRadioTuner::AM) + return true; + else if(b == QRadioTuner::SW) + return false; + else + return false; +} + +void S60RadioTunerControl::setBand(QRadioTuner::Band b) +{ + QRadioTuner::Band tempBand = b; + if (tempBand != m_currentBand) { + m_currentBand = b; + emit bandChanged(m_currentBand); + } +} + +int S60RadioTunerControl::frequency() const +{ + return m_currentFreq; +} + +void S60RadioTunerControl::setFrequency(int frequency) +{ + m_currentFreq = frequency; + m_fmTunerUtility->SetFrequency(m_currentFreq); +} +int S60RadioTunerControl::frequencyStep(QRadioTuner::Band b) const +{ + int step = 0; + if(b == QRadioTuner::FM) + step = 100000; // 100kHz steps + else if(b == QRadioTuner::LW) + step = 1000; // 1kHz steps + else if(b == QRadioTuner::AM) + step = 1000; // 1kHz steps + else if(b == QRadioTuner::SW) + step = 500; // 500Hz steps + + return step; +} + +QPair S60RadioTunerControl::frequencyRange(QRadioTuner::Band band) const +{ + int bottomFreq; + int topFreq; + + int bandError = KErrNone; + TFmRadioFrequencyRange range; + + if (m_fmTunerUtility) { + bandError = m_fmTunerUtility->GetFrequencyRange(range, bottomFreq, topFreq); + } + if (!bandError) { + return qMakePair(bottomFreq, topFreq); + } + + return qMakePair(0,0); +} + +bool S60RadioTunerControl::isStereo() const +{ + return m_isStereo; +} + +QRadioTuner::StereoMode S60RadioTunerControl::stereoMode() const +{ + return m_stereoMode; +} + +void S60RadioTunerControl::setStereoMode(QRadioTuner::StereoMode mode) +{ + if (m_fmTunerUtility) { + if (QRadioTuner::ForceMono == mode) { + m_fmTunerUtility->ForceMonoReception(true); + m_stereoMode = QRadioTuner::ForceMono; + m_isStereo = false; + } else { + m_fmTunerUtility->ForceMonoReception(false); + m_isStereo = true; + m_stereoMode = QRadioTuner::ForceStereo; + } + } +} + +int S60RadioTunerControl::signalStrength() const +{ + // return value is a percentage value + if (m_fmTunerUtility) { + TInt maxSignalStrength; + TInt currentSignalStrength; + m_error = m_fmTunerUtility->GetMaxSignalStrength(maxSignalStrength); + + if (m_error == KErrNone) { + m_error = m_fmTunerUtility->GetSignalStrength(currentSignalStrength); + if (m_error == KErrNone) { + if (currentSignalStrength == 0 || maxSignalStrength == 0) { + return currentSignalStrength; + } + m_signal = currentSignalStrength / maxSignalStrength; + } + } + } + return m_signal; +} + +int S60RadioTunerControl::volume() const +{ + return m_vol; +} + +void S60RadioTunerControl::setVolume(int volume) +{ + if (m_playerUtility) { + m_vol = volume; + volume *= m_volMultiplier; + m_playerUtility->SetVolume(volume); + emit volumeChanged(m_vol); + } +} + +bool S60RadioTunerControl::isMuted() const +{ + return m_muted; +} + +void S60RadioTunerControl::setMuted(bool muted) +{ + if (m_playerUtility) { + m_muted = muted; + m_playerUtility->Mute(m_muted); + } +} + +bool S60RadioTunerControl::isSearching() const +{ + return m_scanning; +} + +void S60RadioTunerControl::cancelSearch() +{ + m_fmTunerUtility->CancelStationSeek(); + m_scanning = false; + emit searchingChanged(false); +} + +void S60RadioTunerControl::searchForward() +{ + m_fmTunerUtility->StationSeek(true); + m_scanning = true; + emit searchingChanged(true); +} + +void S60RadioTunerControl::searchBackward() +{ + m_fmTunerUtility->StationSeek(false); + m_scanning = true; + emit searchingChanged(true); +} + +bool S60RadioTunerControl::isValid() const +{ + return m_available; +} + +bool S60RadioTunerControl::initRadio() +{ + m_available = false; + // create an instance of Radio Utility factory and indicate + // FM Radio is a primary client + TRAPD(utilityError, + m_radioUtility = CRadioUtility::NewL(ETrue); + // Get a tuner utility + m_fmTunerUtility = &m_radioUtility->RadioFmTunerUtilityL(*this); + // we want to listen radio in offline mode too + m_fmTunerUtility->EnableTunerInOfflineMode(ETrue); + // Get a player utility + m_playerUtility = &m_radioUtility->RadioPlayerUtilityL(*this); + ); + if (utilityError != KErrNone) { + m_radioError = QRadioTuner::ResourceError; + return m_available; + } + + m_tunerControl = false; + + m_available = true; + return m_available; +} + +bool S60RadioTunerControl::isAvailable() const +{ + return m_available; +} + +QtMultimediaKit::AvailabilityError S60RadioTunerControl::availabilityError() const +{ + if (m_available) + return QtMultimediaKit::NoError; + else + return QtMultimediaKit::ResourceError; +} + +void S60RadioTunerControl::start() +{ + if (!m_tunerControl) { + m_fmTunerUtility->RequestTunerControl(); + m_apiTunerState = QRadioTuner::ActiveState; + emit stateChanged(m_apiTunerState); + } else { + m_playerUtility->Play(); + m_apiTunerState = QRadioTuner::ActiveState; + emit stateChanged(m_apiTunerState); + } + +} + +void S60RadioTunerControl::stop() +{ + if (m_playerUtility) { + m_playerUtility->Stop(); + m_apiTunerState = QRadioTuner::StoppedState; + emit stateChanged(m_apiTunerState); + } +} + +QRadioTuner::Error S60RadioTunerControl::error() const +{ + return m_radioError; +} +QString S60RadioTunerControl::errorString() const +{ + return m_errorString; +} + +void S60RadioTunerControl::MrpoStateChange(TPlayerState aState, TInt aError) +{ + if (aError == KErrNone){ + m_radioError = QRadioTuner::NoError; + if (aState == ERadioPlayerIdle) { + m_apiTunerState = QRadioTuner::ActiveState; + } else if (aState == ERadioPlayerPlaying) { + m_apiTunerState = QRadioTuner::ActiveState; + } + } + emit stateChanged(m_apiTunerState); +} + +void S60RadioTunerControl::MrpoVolumeChange(TInt aVolume) +{ + m_vol = aVolume; + emit volumeChanged(m_vol); +} + +void S60RadioTunerControl::MrpoMuteChange(TBool aMute) +{ + m_muted = aMute; + emit mutedChanged(m_muted); +} + +void S60RadioTunerControl::MrpoBalanceChange(TInt aLeftPercentage, TInt aRightPercentage) +{ + // no actions +} + +void S60RadioTunerControl::MrftoRequestTunerControlComplete(TInt aError) +{ + if (aError == KErrNone) { + m_playerUtility->GetMaxVolume(m_maxVolume); + m_volMultiplier = float(m_maxVolume)/float(100); + m_radioError = QRadioTuner::NoError; + m_tunerControl = true; + m_available = true; + m_fmTunerUtility->SetFrequency(m_currentFreq); + m_playerUtility->Play(); + int signal = signalStrength(); + if (m_signal != signal) { + emit signalStrengthChanged(signal); + m_signal = signal; + } + + } else if (aError == KFmRadioErrAntennaNotConnected) { + m_radioError = QRadioTuner::OpenError; + } else if (aError == KErrAlreadyExists){ + m_radioError = QRadioTuner::ResourceError; + } else if (aError == KFmRadioErrFrequencyOutOfBandRange) { + m_radioError = QRadioTuner::OutOfRangeError; + }else{ + m_radioError = QRadioTuner::OpenError; + } + +} + +void S60RadioTunerControl::MrftoSetFrequencyRangeComplete(TInt aError) +{ + if (aError == KFmRadioErrFrequencyOutOfBandRange || KFmRadioErrFrequencyNotValid) { + m_radioError = QRadioTuner::OutOfRangeError; + } else if (aError == KFmRadioErrHardwareFaulty || KFmRadioErrOfflineMode) { + m_radioError = QRadioTuner::OpenError; + } +} + +void S60RadioTunerControl::MrftoSetFrequencyComplete(TInt aError) +{ + if (aError == KErrNone) { + m_radioError = QRadioTuner::NoError; + } else if (aError == KFmRadioErrFrequencyOutOfBandRange || KFmRadioErrFrequencyNotValid) { + m_radioError = QRadioTuner::OutOfRangeError; + } else if (aError == KFmRadioErrHardwareFaulty || KFmRadioErrOfflineMode) { + m_radioError = QRadioTuner::OpenError; + } +} + +void S60RadioTunerControl::MrftoStationSeekComplete(TInt aError, TInt aFrequency) +{ + m_scanning = false; + if (aError == KErrNone) { + m_radioError = QRadioTuner::NoError; + m_currentFreq = aFrequency; + } else { + m_radioError = QRadioTuner::OpenError; + } +} + +void S60RadioTunerControl::MrftoFmTransmitterStatusChange(TBool aActive) +{ + //no actions +} + +void S60RadioTunerControl::MrftoAntennaStatusChange(TBool aAttached) +{ + if (aAttached && m_tunerControl) { + m_playerUtility->Play(); + } +} + +void S60RadioTunerControl::MrftoOfflineModeStatusChange(TBool /*aOfflineMode*/) +{ + +} + +void S60RadioTunerControl::MrftoFrequencyRangeChange(TFmRadioFrequencyRange aBand /*, TInt aMinFreq, TInt aMaxFreq*/) +{ + if (aBand == EFmRangeEuroAmerica) { + setBand(QRadioTuner::FM); + } +} + +void S60RadioTunerControl::MrftoFrequencyChange(TInt aNewFrequency) +{ + m_currentFreq = aNewFrequency; + emit frequencyChanged(m_currentFreq); + + int signal = signalStrength(); + if (m_signal != signal) { + emit signalStrengthChanged(signal); + m_signal = signal; + } +} + +void S60RadioTunerControl::MrftoForcedMonoChange(TBool aForcedMono) +{ + if (aForcedMono) { + m_stereoMode = QRadioTuner::ForceMono; + } else { + m_stereoMode = QRadioTuner::ForceStereo; + } + emit stereoStatusChanged(!aForcedMono); +} + +void S60RadioTunerControl::MrftoSquelchChange(TBool aSquelch) +{ + // no actions +}