/*

* Copyright (c) 2006 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:  ?Description

*

*/

#include <e32base.h>

#include "musmanagerclientsession.h"

#include "musmanageripccommon.h"

#include "musmanagercommon.h"

#include "muslogger.h"

#include "musmanager.h"

/* Number of outstanding request can be issued by the client 

   For Mush 8 is normal and if needed it has to be increased 

   Or decreased . If request exceeds this number then that particular

   Request will be considered as part of the global pool of request

*/

#define ASYNCHRONOUS_MESSAGE_SLOTS 255

const TInt KMusServerSessionCreationWaitTimeoutInMicrosecs = 10000000; // 10 secs

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

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

//

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

//

RMusManagerClientSession::RMusManagerClientSession()

    : RSessionBase ()

    {

    }

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

// Use timeout mechanism for session creation as otherwise it can block

// so long that WServ terminates the process. There's no way to cancel

// session creation other than destuction of client session. Therefore, in case

// of timeout, leave and let creation finish silently or get canceled when

// user of client session object deletes us.

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

//

void RMusManagerClientSession::ConnectL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::ConnectL(), with timeout" );

    if ( iSessionCreationStatus.Int() == KRequestPending )

        {

        // Previous creation still pending

        User::Leave( KErrNotReady );

        }

    RTimer timer;

    CleanupClosePushL( timer );

    User::LeaveIfError( timer.CreateLocal() );

    User::LeaveIfError( CreateSession( KMusManagerServerName(), Version(),

                            ASYNCHRONOUS_MESSAGE_SLOTS, &iSessionCreationStatus) );

    TRequestStatus timeoutStatus;

    timer.After( timeoutStatus, KMusServerSessionCreationWaitTimeoutInMicrosecs );

    User::WaitForRequest( iSessionCreationStatus, timeoutStatus );

    if ( timeoutStatus.Int() != KRequestPending )

        {

        MUS_LOG( "mus: [MUSCLI]  RMusManagerClientSession::ConnectL, timeout" );

        User::Leave( KErrTimedOut );

        } 

    else

        {

        MUS_LOG( "mus: [MUSCLI]  RMusManagerClientSession::ConnectL, no timeout" );

        timer.Cancel();

        User::WaitForRequest( timeoutStatus );

        }

    CleanupStack::PopAndDestroy( &timer );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::ConnectL()" );

    }

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

//

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

//

void RMusManagerClientSession::Disconnect()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::Disconnect()" );

    RHandleBase::Close();

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::Disconnect()" );

    }

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

//

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

//

TVersion RMusManagerClientSession::Version(void) const

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::Version()" );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::Version()" );

    return TVersion( KMusManagerServerMajorVersionNumber,

                     KMusManagerServerMinorVersionNumber,

                     KMusManagerServerBuildVersionNumber);

    }

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

//

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

//

void RMusManagerClientSession::InvestigateAvailabilityL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::InvestigateAvailabilityL()" );

    // construct an empty argument

    TIpcArgs ipcArgs( TIpcArgs::ENothing );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcInvestigateAvailability, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::InvestigateAvailabilityL()" );

    }

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

//

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

//

MultimediaSharing::TMusAvailabilityStatus RMusManagerClientSession::QueryAvailabilityL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::QueryAvailabilityL()" );

    TInt capability;

    TPckg<TInt> capPckg( capability );

    // construct a single argument

    TIpcArgs ipcArgs( &capPckg );

    // send and wait for answer

    User::LeaveIfError( SendReceive( EMusManagerIpcAvailabilityQuery, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::QueryAvailabilityL()" );

    return ( MultimediaSharing::TMusAvailabilityStatus ) capability;

    }

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

//

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

//

void RMusManagerClientSession::StartL( MultimediaSharing::TMusUseCase aUseCase )

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::StartL()" );

    TPckg<TInt> pckg( ( TInt ) aUseCase );

    TIpcArgs ipcArgs( &pckg );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcStartMultimediaSharing, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::StartL()" );

    }

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

//

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

//

void RMusManagerClientSession::StartObservingAvailabilityL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::\

    		StartObservingAvailabilityL()" );

    // construct an empty argument

    TIpcArgs ipcArgs( TIpcArgs::ENothing );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcStartObservingAvailability, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::\

    		StartObservingAvailabilityL()" );

    }

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

//

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

//

void RMusManagerClientSession::StopL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::StopL()" );

    // construct an empty argument

    TIpcArgs ipcArgs( TIpcArgs::ENothing );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcStopMultimediaSharing, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::StopL()" );

    }

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

//

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

//

void RMusManagerClientSession::HandleCommandL( 

								MultimediaSharing::TCommandType aCommandType )

	{

	MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::HandleCommandL()" );

    // construct a single argument

    TPckg<TInt> pckg( ( TInt ) aCommandType );

    TIpcArgs ipcArgs( &pckg );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcHandleCommand, ipcArgs ) );    

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::HandleCommandL()" );	

	}

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

//

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

//

void RMusManagerClientSession::HandleSipRequestL( TInt aUid )

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::HandleSipRequestL()" );

    // construct a single argument

    TPckg<TInt> pckg( aUid );

    TIpcArgs ipcArgs( &pckg );

    // Handle sip options in a different way

    if (aUid == CMusManager::ESipOptions)

        {

        MUS_LOG( "mus: [MUSCLI]  -> This is sip options request sending to server" );

        User::LeaveIfError( SendReceive( EMusManagerIpcOptionsReceived, ipcArgs ) );

        }

    else

        {

        MUS_LOG( "mus: [MUSCLI]  -> This is some invitation request sending to server" );

        User::LeaveIfError( SendReceive( EMusManagerIpcInvitationReceived, ipcArgs ) );

        }

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::HandleSipRequestL()" );

    }

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

//

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

//

void RMusManagerClientSession::MonitorAvailabilityL(

                TRequestStatus& aRequestStatus,

                TIpcArgs& aIpcArgs )

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::MonitorAvailabilityL()" );

    SendReceive( 

    	EMusManagerIpcMonitorAvailability, 

    	aIpcArgs,

    	aRequestStatus );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::MonitorAvailabilityL()" );

    }

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

//

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

//

void RMusManagerClientSession::CancelMonitoringL()

    {

    MUS_LOG( "mus: [MUSCLI]  -> RMusManagerClientSession::CancelMonitoring()" );

    // construct an empty argument

    TIpcArgs ipcArgs( TIpcArgs::ENothing );

    // send

    User::LeaveIfError( SendReceive( EMusManagerIpcCancelMonitoring, ipcArgs ) );

    MUS_LOG( "mus: [MUSCLI]  <- RMusManagerClientSession::CancelMonitoring()" );

    }