/*

* 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 class is the main interface to the RadioServer. It implements

*				 the client-side session.

*

*/

// INCLUDE FILES

#include 	<e32math.h>

#include    "StubRadioSession.h"

#include    "RadioClientServer.h"

#include	"RadioRequest.h"

#include	"RadioEventHandler.h"

#include    "RadioDebug.h"

#include    "trace.h"

// CONSTANTS

// Index to list of asynchronous requests that generates response to MRadioObserver.

const TInt KReqInternal				 = 0;

const TInt KReqRequestTunerControl   = 1;

const TInt KReqSetFrequencyRange     = 2;

const TInt KReqSetFrequency          = 3;

const TInt KReqStationSeek           = 4;

const TInt KReqPlay					 = 5;

const TInt KReqStationSeekByPTY      = 6;

const TInt KReqStationSeekByTA       = 7;

const TInt KReqStationSeekByTP       = 8;

// Max number of retries to start the server

const TInt KRadioStartRetry	= 2;

// Minimum of one for each asynchronous message + one to allow cancel

const TInt KRadioMessageSlots = 11;

#define TUNER  iRadioStubManager->iTuner

#define PLAYER  iRadioStubManager->iPlayer

#define RDS  iRadioStubManager->iRds

// ============================= LOCAL FUNCTIONS ===============================

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

// StartServer

// Static function to start the server process thread.

// Start the server process/thread which lives in an EPOCEXE object.

// Returns: TInt: KErrNone (0) if no error

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

//

static TInt StartServer()

	{

    FUNC_LOG;

    const TUidType serverUid(KNullUid, KNullUid, KRadioServerUid3);

    // We just create a new server process. Simultaneous launching of two such

    // processes should be detected when the second one attempts to create

    // the server object, failing with KErrAlreadyExists.

    RProcess server;

    TInt r = server.Create(KRadioServerImg, KNullDesC, serverUid);

    if ( r != KErrNone )

        {

        INFO_1("server.Create() failed [%d]", r);

        return r;

        }

    TRequestStatus stat;

    server.Rendezvous(stat);

    if ( stat != KRequestPending )

        {

        server.Kill(0);     // abort startup

        }

    else

        {

        server.Resume();    // logon OK - start the server

        }

    User::WaitForRequest(stat);     // wait for start or death

    // we can't use the 'exit reason' if the server panicked as this

    // is the panic 'reason' and may be '0' which cannot be distinguished

    // from KErrNone

    r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

    server.Close();

    return r;

	}

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

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

// RRadioSession::NewL

// Two-phased constructor except no need for ConstrucL

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

//

EXPORT_C RRadioSession* RRadioSession::NewL()

    {

    FUNC_LOG;

    RRadioSession* self = new (ELeave) RRadioSession();

    return self;

    }

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

// RRadioSession::RRadioSession

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

// might leave.

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

//

EXPORT_C RRadioSession::RRadioSession()

	:	iConnected(EFalse),

		iDestinationPckg(TMMFMessageDestination(KRadioServerInterfaceUid, KRadioServerObjectHandle)),

		iObserver(NULL),

		iPrimaryClient(EFalse),

		iRdsNotify(EFalse)

    {

    FUNC_LOG;

    }

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

// RRadioSession::Connect

// Create a client-side session. Start the server if not started already.

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

//

EXPORT_C TInt RRadioSession::Connect(

	MRadioObserver& aObserver,

	TBool aPrimaryClient )

	{

    FUNC_LOG;

    INFO_1("Size of RRadioSession: %i", sizeof(RRadioSession) );

    // check if already connected

    if ( iConnected )

        {

        INFO("already connected");

        return KErrAlreadyExists;

        }

    TInt retry = KRadioStartRetry;

    TInt err = KErrGeneral;

    TInt numMessageSlots = KRadioMessageSlots;

    for (;;)

        {

        // Try to create a new session with the server

        err = CreateSession(KRadioServerName, Version(), numMessageSlots);

        if ( (err != KErrNotFound) && (err != KErrServerTerminated) )

            {

            break;  // Connected to existing server - ok

            }

        if ( --retry == 0 )

            {

            break;  // Failed.

            }

        // Server not running, try to start it.

        err = StartServer();

        if ( (err != KErrNone) && (err != KErrAlreadyExists) )

            {

            break;  // Server not launched - propagate error

            }

        }

    if ( err != KErrNone )

        {

        INFO_1("Unable to start server [%d]", err);

        return err;

        }

    // Dooing some temporary manipulation for heap

    User::Check();

    User::CompressAllHeaps();

    CRadioRequest* req( NULL );

    TRAP(err, req = CRadioRequest::NewLC(*this, aObserver, ERadioServNone); CleanupStack::Pop( req ) );

    iExtraRequestForBugHunting = req;   

    User::Check();

    User::CompressAllHeaps();

    //delete iExtraRequestForBugHunting;

    //iExtraRequestForBugHunting = NULL;

    // Create active object request handlers and add it to scheduler

    TRAP(err, StartRequestHandlersL(aObserver));

    if ( err == KErrNone )

        {

        // Create active object event handlers and add it to scheduler

        TRAP(err, StartEventHandlersL(aObserver));

        if ( err == KErrNone )

            {

            iConnected = ETrue;

            iObserver = &aObserver;

            if ( aPrimaryClient )

                {

                iPrimaryClient = ETrue;

                err = SendReceive(ERadioServAddPrimaryClient, TIpcArgs(&iDestinationPckg));

                }

            }

        else

            {

            iRequests.ResetAndDestroy();

            iEventHandlers.ResetAndDestroy();

            }

        }

    else

        {

        iRequests.ResetAndDestroy();

        }

    // Open chunk for test configuration/control data

    // Open chunk for test configuration/control data

    User::Check();

    User::CompressAllHeaps();

    err = iRadioStubManagerChunk.OpenGlobal(

            KRadioStubManagerLocalChunkName,

            EFalse, // == Read | Write

            EOwnerThread );

    if (err)

        {

        goto exitAndReturn;

        }

    User::Check();

    User::CompressAllHeaps();

    if ( sizeof(SRadioStubManager) > iRadioStubManagerChunk.MaxSize() )

        {

        err =  KErrTooBig;

        goto exitAndReturn;

        }

    TUint8* basePtr = iRadioStubManagerChunk.Base();

    User::LeaveIfNull( basePtr );    

    if (!basePtr)

        {

        err = KErrGeneral;

        goto exitAndReturn;

        }    

    User::Check();

    User::CompressAllHeaps();

    iRadioStubManager = (SRadioStubManager*)basePtr;    

exitAndReturn:    

    User::Check();

    User::CompressAllHeaps();

    INFO_1("exit err=[%d]", err);

    return err;

	}

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

// RRadioSession::Version

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

//

EXPORT_C TVersion RRadioSession::Version() const

	{

	return(TVersion(KRadioServerVersionMajor, KRadioServerVersionMinor, KRadioServerVersionBuild));

	}

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

// RRadioSession::Close

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

//

EXPORT_C void RRadioSession::Close()

	{

    FUNC_LOG;

    //delete iExtraRequestForBugHunting;

    iEventHandlers.ResetAndDestroy();

    iEventHandlers.Close();

    iRdsEventHandlers.ResetAndDestroy();

    iRdsEventHandlers.Close();

    for ( TInt i = (iRequests.Count() - 1) ; i >= 0; i = (iRequests.Count()- 1)  )

        {

        INFO_2("iRequests[i] pointer: 0x%x, no: %i", *&iRequests[i], i );

        CRadioRequest* req = *&iRequests[i];

        iRequests.Remove(i);

        delete req;

        }   

    //iRequests.ResetAndDestroy();

    iRequests.Close();

    if ( iConnected )

        {

        iConnected = EFalse;

        if ( iPrimaryClient )

            {

            SendReceive(ERadioServRemovePrimaryClient, TIpcArgs(&iDestinationPckg));

            }

        RSessionBase::Close();

        }

    // Dooing some temporary manipulation for heap

    //User::Check();

    //User::CompressAllHeaps();

    delete iExtraRequestForBugHunting;

	}

//********** TunerUtility control begins

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

// RRadioSession::RequestTunerControl

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

//

EXPORT_C void RRadioSession::RequestTunerControl(

	TRsTuner /*aTuner*/ )

	{

    FUNC_LOG;

	if ( iConnected )

		{

        if ( !iRequests[KReqRequestTunerControl]->IsActive() )

            {

            iRequests[KReqRequestTunerControl]->CompleteRequest(ERadioServRequestTunerControl, KErrNone);

            }

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServRequestTunerControl, KErrDisconnected);

		}

	}

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

// RRadioSession::GetTunerCapabilities

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

//

EXPORT_C TInt RRadioSession::GetTunerCapabilities(

	TRsTunerCapabilities& aCaps ) const

	{

    FUNC_LOG;

	if ( iConnected )

		{

        TInt err( TUNER.iGetCapabilitiesError.Error() );

        if ( KErrNone == err )

            {

            aCaps.iFrequencyRange = TUNER.iCaps.iFrequencyRange;

            aCaps.iCapabilities = TUNER.iCaps.iCapabilities;

            aCaps.iAdditionalFunctions1 = TUNER.iCaps.iAdditionalFunctions1;

            aCaps.iAdditionalFunctions2 = TUNER.iCaps.iAdditionalFunctions2;            

            }

	    return err;

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::EnableTunerInOfflineMode

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

//

EXPORT_C TInt RRadioSession::EnableTunerInOfflineMode(

	TBool aEnable )

	{

    FUNC_LOG;

	if ( iConnected )

		{

        TInt err( TUNER.iEnableTunerInOfflineModeError.Error() );

        if ( KErrNone == err )

            {

            TUNER.iTunerInOfflineMode = aEnable;

            }

	    return err;

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::SetFrequencyRange

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

//

EXPORT_C void RRadioSession::SetFrequencyRange(

	TRsFrequencyRange aRange )

	{

    FUNC_LOG;

	if ( iConnected )

		{

        TInt err( TUNER.iSetFrequencyRangeError.Error() );

        if ( KErrNone == err )

            {

            TUNER.iPreviousRange = TUNER.iRange;

            TUNER.iRange = aRange;

            }

        if ( iRequests[KReqSetFrequencyRange]->IsActive() )

            {

            iRequests[KReqSetFrequencyRange]->Cancel();

            }

        iRequests[KReqSetFrequencyRange]->CompleteRequest(ERadioServSetFrequencyRange, err);

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequencyRange, KErrDisconnected);

		}

	}

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

// RRadioSession::CancelSetFrequencyRange

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

//

EXPORT_C void RRadioSession::CancelSetFrequencyRange()

	{

    FUNC_LOG;

	if ( iConnected && iRequests[KReqSetFrequencyRange]->IsActive() )

		{

		iRequests[KReqSetFrequencyRange]->Cancel();

		}

	}

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

// RRadioSession::GetFrequencyRange

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

//

EXPORT_C TInt RRadioSession::GetFrequencyRange(

	TRsFrequencyRange& aRange,

	TInt& aMinFreq,

	TInt& aMaxFreq) const

	{

    FUNC_LOG;

	if ( iConnected )

		{

        TInt err( TUNER.iGetFrequencyRangeError.Error() );

        if ( KErrNone == err )

            {

            aRange = TUNER.iRange;

            aMinFreq = TUNER.iMinFreq;

            aMaxFreq = TUNER.iMaxFreq;

            }

	    return err;

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::SetFrequency

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

//

EXPORT_C void RRadioSession::SetFrequency(

	TInt aFrequency )

	{

    FUNC_LOG;

	if ( iConnected )

		{

	    TUint err( TUNER.iSetFrequencyError.Error() );

	    if  ( KErrNone == err )

	        {

	        TUNER.iPreviousFrequency = TUNER.iFrequency;

	        TUNER.iFrequency = aFrequency;

	        }       

        if ( iRequests[KReqSetFrequency]->IsActive() )

            {

            iRequests[KReqSetFrequency]->Cancel();

            }

        iRequests[KReqSetFrequency]->CompleteRequest(ERadioServSetFrequency, err);

		}

	else

		{

		iRequests[KReqInternal]->CompleteRequest(ERadioServSetFrequency, KErrDisconnected);

		}

	}

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

// RRadioSession::CancelSetFrequency

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

//

EXPORT_C void RRadioSession::CancelSetFrequency()

	{

    FUNC_LOG;

	if ( iConnected && iRequests[KReqSetFrequency]->IsActive() )

		{

		iRequests[KReqSetFrequency]->Cancel();

		}

    TUNER.iFrequency = TUNER.iPreviousFrequency;

    TUNER.iPreviousFrequency = 0;

	}

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

// RRadioSession::GetFrequency

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

//

EXPORT_C TInt RRadioSession::GetFrequency(

	TInt& aFrequency ) const

	{

    FUNC_LOG;

	if ( iConnected )

		{

        TInt err( TUNER.iGetFrequencyError.Error() );

        if ( KErrNone == err )

            {

            aFrequency = TUNER.iFrequency;

            }

	    return err;

		}

	else

		{

		return KErrDisconnected;

		}

	}

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

// RRadioSession::StationSeek

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

EXPORT_C void RRadioSession::StationSeek(

	TBool aUpwards )

	{

    FUNC_LOG;

    INFO_1("aUpwards: %D", aUpwards );

	if ( iConnected )

		{

	    TUNER.iStationSeekUpwards = aUpwards;

        if ( iRequests[KReqStationSeek]->IsActive() )

            {

            iRequests[KReqStationSeek]->Cancel();

            }

        TInt err( KErrNone);

        if ( KErrNotFound == TUNER.iScanStations.iCount )

            {

            err = KErrNotFound;

            }

        else if ( TUNER.iScanStations.iCount )

            {

            iRequests[KReqStationSeek]->iInt = TUNER.iScanStations.iMinFreq + ( TUNER.iScanStations.iCount * TUNER.iScanStations.iFrequencyStepSize );

            --TUNER.iScanStations.iCount;

            if ( 0 == TUNER.iScanStations.iCount )

                {

                TUNER.iScanStations.iCount = KErrNotFound;

                }