/*

* Copyright (c) 2002-2004 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:  This is the main implementation of radio server.

*

*/

// INCLUDE FILES

#include    <mmf/common/mmfstandardcustomcommands.h>

#include    <centralrepository.h>

#include    <coreapplicationuissdkcrkeys.h>

#include    <audiopreference.h>

#include    "RadioServer.h"

#include    "RadioServerSession.h"

#include    "RadioServerShutdown.h"

#include    "RadioServerSettings.h"

#include    "RadioServerFmTuner.h"

#include    "RadioDebug.h"

// CONSTANTS

const TInt KFMDefaultFreq           = 87500000; // 87.5 MHz

const TInt KJapaneseFMDefaultFreq   = 76000000; // 76.0 MHz

#ifndef RD_FM_RADIO_ENHANCEMENTS

const TInt KEuroAmericaMin  =  87500000;

const TInt KEuroAmericaMax  = 108000000;

const TInt KJapanMin        =  76000000;

const TInt KJapanMax        =  90000000;

#endif //#ifdef RD_FM_RADIO_ENHANCEMENTS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CRadioServer::CRadioServer

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CRadioServer::CRadioServer()

    :   CServer2(CActive::EPriorityStandard),

        iState(EStateStarted),

        iSessionCount(0),

        iSessionCountPrimary(0),

        iShutdownTimer(NULL),

        iSettings(NULL),

        iTunerControlObserver(NULL),

        iTunerControl(NULL),

        iRdsControl(NULL),

        iDevSound(NULL),

        iRepository(NULL),

        iCenRepNotifyHandler(NULL),

        iAsyncRequestQue(_FOFF( TRadioMessageRequestData, iLink )),

        iAsyncRequest(NULL),

        iSyncRequestQue(_FOFF( TRadioMessageRequestData, iLink )),

        iSyncRequest(NULL),

        iMaxSigStrength(0),

        iEnableTunerInOffline(EFalse),

        iSquelch(EFalse),

        iPreEmpted(EFalse)

    {

    }

// -----------------------------------------------------------------------------

// CRadioServer::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CRadioServer::ConstructL()

    {

    RADIO_RDEBUG(_L("[RADIO-SVR] ConstructL() - Start"));

    StartL(KRadioServerName);

    iDevSound = CMMFDevSound::NewL();

    TMMFPrioritySettings prioritySettings;

    prioritySettings.iPriority = (TInt)KAudioPriorityFMRadio;

    prioritySettings.iPref = (TMdaPriorityPreference)KAudioPrefRadioAudioEvent;

    iDevSound->SetPrioritySettings(prioritySettings);

    // Sign up for offline mode status notification and get the latest status

    iRepository = CRepository::NewL(KCRUidCoreApplicationUIs);

    iCenRepNotifyHandler = CCenRepNotifyHandler::NewL(*this, *iRepository,

            CCenRepNotifyHandler::EIntKey, KCoreAppUIsNetworkConnectionAllowed);

    iCenRepNotifyHandler->StartListeningL();

    TInt value;

    TBool offlineMode = EFalse;

    iRepository->Get(KCoreAppUIsNetworkConnectionAllowed, value);

    if ( (TCoreAppUIsNetworkConnectionAllowed)value == ECoreAppUIsNetworkConnectionNotAllowed )

        {

        offlineMode = ETrue;

        }

    // Assume Antenna is connected. Otherwise, initialization will handle it anyways.

    // After that, RadioServer gets the antenna status notification from the tuner.

    TBool antennaStatus = ETrue;

    // Max volume won't change, so just make the server remember it locally.

    iMaxVolume = iDevSound->MaxVolume();

    TInt volume = iDevSound->Volume();

    TInt left, right;

    iDevSound->GetPlayBalanceL(left, right);

    iSettings = CRadioServerSettings::NewL();

    iSettings->SetAntennaStatus(antennaStatus, EFalse);

    iSettings->SetOfflineModeStatus(offlineMode, EFalse);

    iSettings->SetVolume(volume, EFalse);

    iSettings->SetBalance(left, right, EFalse);

    // Initiate shut down unless we get client connections

    iShutdownTimer = CRadioServerShutdown::NewL();

    iShutdownTimer->Start();

#ifdef RD_TSP_CLIENT_MAPPER

    iMapper = CTspClientMapper::NewL();

    iTspState = CTspClientMapper::ERegisteredClients;

#endif // RD_TSP_CLIENT_MAPPER

    RADIO_RDEBUG(_L("[RADIO-SVR] ConstructL() - End"));

    }

// -----------------------------------------------------------------------------

// CRadioServer::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CRadioServer* CRadioServer::NewL()

    {

    RADIO_RDEBUG(_L("[RADIO-SVR] NewL"));

    CRadioServer* self = new( ELeave ) CRadioServer;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CRadioServer::~CRadioServer()

    {

    if ( iShutdownTimer )

        {

        iShutdownTimer->Cancel();

        delete iShutdownTimer;

        }

    if ( iCenRepNotifyHandler )

        {

        iCenRepNotifyHandler->StopListening();

        delete iCenRepNotifyHandler;

        }

    delete iRepository;

    delete iDevSound;

    delete iSettings;

    delete iTunerControl;

    delete iTunerControlObserver;

    delete iAsyncRequest;

    ClearQueue();

    iRdsNotifyClientIdArray.Close();

#ifdef RD_TSP_CLIENT_MAPPER

    delete iMapper;

    iClientPids.Close();

#endif // RD_TSP_CLIENT_MAPPER

    }

// -----------------------------------------------------------------------------

// CRadioServer::AddSession

// This method increases the client session count, and cancels the shutdown timer.

// The timer is reset once the last client has disconnected

// -----------------------------------------------------------------------------

//

void CRadioServer::AddSession()

    {

    if ( ++iSessionCount == 1 )

        {

        iShutdownTimer->Cancel();

        iState = EStateStarted;

        }

    }

// -----------------------------------------------------------------------------

// CRadioServer::DropSession

// This method decrements the client session count, and if no clients are connected,

// it initiates the shutdown timer.

// -----------------------------------------------------------------------------

//

void CRadioServer::DropSession()

    {

    if ( --iSessionCount == 0 )

        {

        RADIO_RDEBUG_INT(_L("[RADIO-SVR] DropSession() - Radio OFF. State[%d]"), iState);

        switch ( iState )

            {

            case EStateStarted:

            case EStateTunerOff:

                // Shutting down normally.

                iState = EStateStarted;

                iMaxSigStrength = 0;

                iEnableTunerInOffline = EFalse;

                delete iTunerControl;

                iTunerControl = NULL;

                ClearQueue();

                iShutdownTimer->Start();

                break;

            case EStateTunerOn:

                iState = EStateShutdown;

                iTunerControl->TunerOff();

                break;

            case EStatePlaying:

                iState = EStateShutdown;

                iDevSound->Stop();

                iTunerControl->TunerOff();

                break;

            default:

                break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CRadioServer::ServiceRequestL

// Main entry for Radio Server. If the cancel-request message is already outstanding,

// just let it complete. Only allow for cancel if the message hasn't been initiated yet.

// For all other requests, process the message if no other outstanding message exists.

// Otherwise, queue the message. Execution order is guaranteed for all asynchronous

// requests.

// -----------------------------------------------------------------------------

//

void CRadioServer::ServiceRequestL(

    const RMessage2& aMessage )

    {

    TRadioServerRequest req;

    TRadioMessageRequestData* data = NULL;

#ifdef RD_TSP_CLIENT_MAPPER

    iMessageTsp = aMessage;

#endif // RD_TSP_CLIENT_MAPPER

    switch( aMessage.Function() )

        {

        case ERadioServAddPrimaryClient:

            iSessionCountPrimary++;

            RegisterClientPidL(aMessage);

            RADIO_RDEBUG_INT(_L("[RADIO-SVR] ServiceRequestL() prim=[%d]"), iSessionCountPrimary);

            aMessage.Complete(KErrNone);

            break;

        case ERadioServRemovePrimaryClient:

            aMessage.Complete(ProcessRemovePrimaryClientL(aMessage));

            break;

        case ERadioServGetTunerCapabilities:

            aMessage.Complete(ProcessGetTunerCapabilities(aMessage));

            break;

        case ERadioServEnableTunerInOfflineMode:

            aMessage.Complete(ProcessEnableTunerInOfflineMode(aMessage.Int1()));

            break;

        case ERadioServGetFrequencyRange:

            aMessage.Complete(ProcessGetFrequencyRange(aMessage));

            break;

        case ERadioServGetFrequency:

            aMessage.Complete(ProcessGetFrequency(aMessage));

            break;

        case ERadioServGetForceMonoReception:

            aMessage.Complete(ProcessGetForceMonoReception(aMessage));

            break;

        case ERadioServSetSquelch:

            aMessage.Complete(ProcessSetSquelch(aMessage.Int1()));

            break;

        case ERadioServGetSquelch:

            aMessage.Complete(ProcessGetSquelch(aMessage));

            break;

        case ERadioServGetSignalStrength:

        case ERadioServGetMaxSignalStrength:

        case ERadioServGetStereoMode:

        case ERadioServForceMonoReception:

            // These requests are synchronous request from the client, however, the corresponding

            // request to the tuner control is asynchronous. Therefore, these messages need to be

            // serialized using a queue.

            data = new (ELeave) TRadioMessageRequestData;

            data->iType = (TRadioServerRequest) aMessage.Function();

            data->iMessage = aMessage;

            if ( iSyncRequest )

                {

                // Outstanding request exits; add it to the queue

                iSyncRequestQue.AddLast(*data);

                }

            else

                {

                // No outstanding request; process the request

                ProcessSyncRequest(data);

                }

            break;

        case ERadioServGetPlayerState:

            aMessage.Complete(ProcessGetPlayerState(aMessage));

            break;

        case ERadioServGetMaxVolume:

            aMessage.Complete(ProcessGetMaxVolume(aMessage));

            break;

        case ERadioServSetVolume:

            aMessage.Complete(ProcessSetVolume(aMessage.Int1()));

            break;

        case ERadioServGetVolume:

            aMessage.Complete(ProcessGetVolume(aMessage));

            break;

        case ERadioServSetVolumeRamp:

            aMessage.Complete(ProcessSetVolumeRamp(aMessage));

            break;

        case ERadioServSetMute:

            aMessage.Complete(ProcessSetMute(aMessage.Int1()));

            break;

        case ERadioServGetMuteStatus:

            aMessage.Complete(ProcessGetMuteStatus(aMessage));

            break;

        case ERadioServSetBalance:

            aMessage.Complete(ProcessSetBalance(aMessage.Int1(), aMessage.Int2()));

            break;

        case ERadioServGetBalance:

            aMessage.Complete(ProcessGetBalance(aMessage));

            break;

        case ERadioServRequestTunerControl:

        case ERadioServSetFrequencyRange:

        case ERadioServSetFrequency:

        case ERadioServStationSeek:

        case ERadioServPlay:

        case ERadioServStop:

        case ERadioServStationSeekByPTY:

        case ERadioServStationSeekByTA:

        case ERadioServStationSeekByTP:

            // These requests are asynchronous request from the client. In order to guarantee the

            // execution order these messages are serialized using a queue.

            data = new (ELeave) TRadioMessageRequestData;

            data->iType = (TRadioServerRequest) aMessage.Function();

            data->iMessage = aMessage;

            if ( iAsyncRequest )

                {

                // Outstanding request exits; add it to the queue

                iAsyncRequestQue.AddLast(*data);

                }

            else

                {

                // No outstanding request; process the request

                ProcessAsyncRequest(data);

                }

            break;

        case ERadioServGetRdsCapabilities:

            aMessage.Complete(ProcessGetRdsCapabilities(aMessage));

            break;

        case ERadioServGetRdsSignalStatus:

            aMessage.Complete(ProcessGetRdsSignalStatus(aMessage));

            break;

        case ERadioServNotifyRdsDataChange:

            aMessage.Complete(ProcessNotifyRdsDataChange(aMessage));

            break;

        case ERadioServCancelNotifyRdsDataChange:

            aMessage.Complete(ProcessCancelNotifyRdsDataChange(aMessage));

            break;

        case ERadioServSetAutomaticSwitching:

            aMessage.Complete(ProcessSetAutomaticSwitching(aMessage.Int1()));

            break;

        case ERadioServGetAutomaticSwitching:

            aMessage.Complete(ProcessGetAutomaticSwitching(aMessage));

            break;

        case ERadioServCancelAFSearch:

            aMessage.Complete(ProcessCancelAFSearch());

            break;

        case ERadioServGetProgrammeIdentification:

            aMessage.Complete(ProcessGetProgrammeIdentification(aMessage));

            break;

        case ERadioServGetProgrammeType:

            aMessage.Complete(ProcessGetProgrammeType(aMessage));

            break;

        case ERadioServGetProgrammeService:

            aMessage.Complete(ProcessGetProgrammeService(aMessage));

            break;

        case ERadioServGetRadioText:

            aMessage.Complete(ProcessGetRadioText(aMessage));

            break;

        case ERadioServGetClockTime:

            aMessage.Complete(ProcessGetClockTime(aMessage));

            break;

        case ERadioServGetTrafficAnnouncementStatus:

            aMessage.Complete(ProcessGetTrafficAnnouncementStatus(aMessage));

            break;

        case ERadioServGetTrafficProgrammeStatus:

            aMessage.Complete(ProcessGetTrafficProgrammeStatus(aMessage));

            break;

        case ERadioServCancel:

            req = (TRadioServerRequest) aMessage.Int1();

            RADIO_RDEBUG_INT(_L("[RADIO-SVR] ServiceRequestL(): Cancel[%d]"), req);

            switch ( req )

                {

                case ERadioServRequestTunerControl:

                case ERadioServSetFrequencyRange:

                case ERadioServSetFrequency:

                    // If the message has already executed or is outstanding, just let it complete.

                    // If not, remove from queue.

                    RemoveFromQueue(iAsyncRequestQue, req);

                    aMessage.Complete(KErrNone);

                    break;

                case ERadioServStationSeek:

                case ERadioServStationSeekByPTY:

                case ERadioServStationSeekByTA:

                case ERadioServStationSeekByTP:

                    // If the request is outstanding, attempt to cancel since it can take a while

                    // to complete. Otherwise, just remove from the queue.

                    if ( iAsyncRequest && ( (iAsyncRequest->iType == ERadioServStationSeek) ||

                                            (iAsyncRequest->iType == ERadioServStationSeekByPTY) ||

                                            (iAsyncRequest->iType == ERadioServStationSeekByTA) ||

                                            (iAsyncRequest->iType == ERadioServStationSeekByTP) ) )

                        {

                        RADIO_RDEBUG(_L("[RADIO-SVR] ServiceRequestL() - Seek Outstanding"));

                        if ( iAsyncRequest->iType == ERadioServStationSeek )

                            {

                            iTunerControl->CancelStationSeek();

                            }

                        else

                            {

                            iRdsControl->CancelRdsStationSeek();

                            }

                        // Disable squelching, if on

                        if ( iSquelch )

                            {

                            // Restore the last volume

                            iDevSound->SetVolume(iSettings->Volume());

                            iSquelch = EFalse;

                            }

                        }

                    else

                        {

                        RemoveFromQueue(iAsyncRequestQue, req);

                        }

                    aMessage.Complete(KErrNone);

                    break;

                default:

                    RADIO_RDEBUG(_L("[RADIO-SVR] ServiceRequestL(): default !!!"));

                    // Could be some custom command that we don't support.

                    aMessage.Complete(KErrNotSupported);

                }

            break;

        default:

            RADIO_RDEBUG(_L("[RADIO-SVR] ServiceRequestL(): default!!!"));

            // Could be some custom command that we don't support.

            aMessage.Complete(KErrNotSupported);

            break;

        }

    }

// -----------------------------------------------------------------------------

// CRadioServer::NewSessionL

// This method decrements the client session count, and if no clients are connected,

// it initiates the shutdown timer.

// -----------------------------------------------------------------------------

//

CSession2* CRadioServer::NewSessionL(

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/ ) const

    {

    // Test if the version specifies a repository session

    const TVersion version(KRadioServerVersionMajor,

                           KRadioServerVersionMinor,

                           KRadioServerVersionBuild);

    if ( !User::QueryVersionSupported(aVersion, version) )

        {

        User::Leave(KErrNotSupported);

        }

    CRadioServerSession* session = CRadioServerSession::NewL(*((CRadioServer*)this));

    return session;

    }

// -----------------------------------------------------------------------------

// CRadioServer::TunerOnComplete (From MRadioServerFMTunerObserver)

// -----------------------------------------------------------------------------

//

void CRadioServer::TunerOnComplete(

    TRadioServerError aError )

    {

    RADIO_RDEBUG_INT3(_L("[RADIO-SVR] TunerOnComplete(%d) State[%d] Trigger[%d]"), aError, iState, iTunerOnTrigger);

    TFourCC radioFourCC;

    switch ( iTunerOnTrigger )

        {

        case ETriggerTunerControl:

            if ( aError == KErrNone )

                {

                TRsFrequencyRange range;

                TInt minFreq, maxFreq;

                if ( GetFrequencyRange(range, minFreq, maxFreq) == KErrNone )

                    {

                    RADIO_RDEBUG_INT3(_L("[RADIO-SVR] TunerOnComplete() - [%d, %d, %d]"), range, minFreq, maxFreq);

                    iSettings->SetFrequencyRange( range, minFreq, maxFreq, EFalse );

                    }

                radioFourCC.Set(iTunerCaps.iEncoding);

                TRAPD(err, iDevSound->InitializeL(*this, radioFourCC, EMMFStatePlaying));

                if ( err != KErrNone )

                    {

                    RADIO_RDEBUG_INT(_L("[RADIO-SVR] TunerOnComplete() DevSound err=[%d]"), err);

                    CompleteAsyncRequest(err);

                    }

                }

            else

                {

                CompleteAsyncRequest(aError);

                }

            break;

        case ETriggerSetFrequency:

            if ( aError == KErrNone )

                {

                iState = EStateTunerOn;

                }

            CompleteAsyncRequest(aError);

            break;

        case ETriggerSetFrequencyRange:

            if ( aError == KErrNone )

                {

                iState = EStateTunerOn;

                TRsFrequencyRange range;

                TInt minFreq, maxFreq;

                if ( GetFrequencyRange(range, minFreq, maxFreq) == KErrNone )