/*

* Copyright (c) 2007-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:  Client side of Tactile Feedback server.

* Part of:      Tactile Feedback.

*

*/

#include <e32base.h>

#include <e32std.h>

#include <ecom/ecom.h>

#include <e32debug.h>

#include <tactilefeedback.h>

#include "tactilefeedbacktrace.h"

#include "tactilefeedbacksrv.h"

#include "tactilefeedbackdefs.h"

/**

 * Own active scheduler class. We need this so that we can override the

 * CActiveScheduler::Error -function and avoid panic in case something

 * leaves.

 */

NONSHARABLE_CLASS( CTactileScheduler ): public CActiveScheduler

    {

public:   

    /**

     * This is called when something leaves in our Feedback Player

     * thread.

     */

    void Error( TInt aError ) const;

    };

void CTactileScheduler::Error( TInt aError ) const

    {

    (void) aError; // Remove compiler warning in armv5 urel

    TRACE2( "CTactileScheduler::Error, aError = %d", aError );

    }

/**

 * Structure for the parameters, that are passed to Feedback Player Thread

 * when it is created.

 */

struct TTactileThreadParams

    {

    RThread* iOwningThread;

    TInt iQueueHandle;

    };

/**

 * Class for creating new thread for Tactile Feedback playing, and

 * for passing feedback requests to the thread via a message queue.

 */

NONSHARABLE_CLASS( CThreadPlayer ): public CBase

    {

public:

    static CThreadPlayer* NewL();

    ~CThreadPlayer();

private:

    CThreadPlayer() {};

    void ConstructL();

    static void RunThreadL( TAny* aParam );

    static TInt ThreadEntryPoint( TAny* aParam );

    RThread                 iThread;

    };    

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

// Here we create and start new thread for Tactile Feedback Playing.

//

// If this function returns succesfully, then the new thread was created ok

// and is now running. Otherwise we leave from here.

//

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

//

void CThreadPlayer::ConstructL()

    {

    TRACE("CThreadPlayer::ConstructL - Begin");

    RThread thisThread;

    CleanupClosePushL( thisThread );

    TTactileThreadParams params;

    params.iOwningThread = &thisThread;

    User::LeaveIfError( 

        iThread.Create( 

            KTactileThreadName, 

            ThreadEntryPoint,

            KPlayerThreadStackSize, 

            KPlayerThreadHeapMinSize, 

            KPlayerThreadHeapMaxSize,

            &params, 

            EOwnerProcess ) );       

    // With EPriorityMore feedback player thread operates with the same

    // priority as window server main thread. This seems to be the best

    // choice for now, as this way neither drawing or feedback can cause

    // significant delay for each other.

    iThread.SetPriority( EPriorityMore );

    iThread.Resume();

    // We have to wait so that our thread has read the parameters

    TRequestStatus status;

    iThread.Rendezvous( status );

    User::WaitForRequest( status );

    // Store thread exit type while we still have handles open

    TExitType exitType = iThread.ExitType(); 

    // Close thread handle to ourself.  

    CleanupStack::PopAndDestroy( &thisThread ); 

    // Check that rendezvouz succeeded, and that thread is still alive

    if ( exitType != EExitPending || status != KErrNone )

        {

        TRACE3("CThreadPlayer::ConstructL - Thread creation failed, %d, %d", exitType, status.Int() );

        User::Leave( KErrGeneral );

        }

    TRACE("CThreadPlayer::ConstructL - End");

    }

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

//

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

//

CThreadPlayer* CThreadPlayer::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// We close our player thread by sending an exit request and waiting for

// the thread to close itself. This way all resources get closed cleanly.

//

// In case message queue is full, then we'll just kill the thread.

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

//

CThreadPlayer::~CThreadPlayer()

    {

    if ( iThread.Handle() )

        {

        TExitType exitType = iThread.ExitType(); 

        if ( exitType == EExitPending )

            {

            iThread.Kill( KErrAbort );

            }

        iThread.Close();

        }

    }

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

// Rest of the actions required for setting Tactile Feedback Player thread

// up and running (this is called from ThreadEntryPoint)

//

// #1 Create and install an active scheduler

// #2 Create server instance.

// #3 Notify main thread that we are ready to run (this allows main thread 

//    to continue).

// #4 Start the scheduler. Excecution will halt here in this functio until

//    somebody stops the scheduler.

//

// #5 Delete server and scheduler (at this point we are exiting our thread 

//    already).

//

// #6 Close ECom session, as we are now exiting the thread (this is on our

//    responsibility even though we are not directly using Ecom).

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

//

void CThreadPlayer::RunThreadL( TAny* /*aParam*/ )

    {

    // #1

    CTactileScheduler* s = new(ELeave) CTactileScheduler;

    CleanupStack::PushL(s);

    CActiveScheduler::Install(s);

    // #2

    CTactileFeedbackSrv* svr = CTactileFeedbackSrv::NewL();

    // #3

    RThread me;

    me.Rendezvous( KErrNone ); 

    // #4    

    CActiveScheduler::Start();

    // #5

    delete svr;

    CleanupStack::PopAndDestroy( s );

    // #6

    REComSession::FinalClose();

    }

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

// This is the entry point of Tactile feedback player thread.

//

// Standard operation: Create cleanup stack and call rest of the code under

// trap harness.

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

//

TInt CThreadPlayer::ThreadEntryPoint( TAny* aParam )

    {

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt err( KErrNoMemory );

    if ( cleanup )

        {

        TRAP( err, CThreadPlayer::RunThreadL( aParam ) );

        delete cleanup;

        }

    __UHEAP_MARKEND;

    return err;

    }    

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

// Default constructor.

// 

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

//       

EXPORT_C RTactileFeedback::RTactileFeedback() 

    {

    }

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

// 

// Creates connection to server

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

//

EXPORT_C TInt RTactileFeedback::Connect()

    {

    TInt ret = CreateSession( KTactileFeedbackServer, Version() );

    if (  ret != KErrNone )

        {

        TRAP( ret, iThread = CThreadPlayer::NewL() );

        if ( ret == KErrNone )

            {

            ret = CreateSession( KTactileFeedbackServer, Version() );    

            }        

        }

    return ret; 

    }

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

// 

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

//      

EXPORT_C void RTactileFeedback::Close()

    {

    delete iThread;

    iThread = NULL;

    // close session    

    RSessionBase::Close();

    }    

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

// 

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

//     

EXPORT_C void RTactileFeedback::PlayFeedback( TTouchLogicalFeedback aFeedbackType,

                                              TBool aPlayVibra,

                                              TBool aPlayAudio )

    {

    SendReceive( EPlayFeedback, TIpcArgs( aFeedbackType, 

                                          aPlayVibra, 

                                          aPlayAudio ) );    

    }

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

// 

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

//    

EXPORT_C void RTactileFeedback::StartFeedback( TTouchContinuousFeedback aType,

                                              TInt aIntensity )

    {

    TRACE("RTactileFeedback::StartFeedback");

    SendReceive( EStartFeedback, TIpcArgs( aType, aIntensity ) );

    }

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

// 

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

//                        

EXPORT_C void RTactileFeedback::ModifyFeedback( TInt aIntensity )

    {

    TRACE("RTactileFeedback::ModifyFeedback");

    SendReceive( EModifyFeedback, TIpcArgs( aIntensity ) );

    }

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

// 

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

//    

EXPORT_C void RTactileFeedback::StopFeedback()

    {

    TRACE("RTactileFeedback::StopFeedback");

    SendReceive( EStopFeedback );   

    }

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

// 

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

//    

EXPORT_C TInt RTactileFeedback::SetFeedbackEnabledForDevice( TTouchFeedbackType aFeedbackType )

    {

    TRACE("RTactileFeedback::StopFeedback");

    return SendReceive( ESetFBEnabledDevice, TIpcArgs( aFeedbackType ) );   

    }    

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

// 

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

//        

EXPORT_C void RTactileFeedback::FeedbackEnabledForDevice( TTouchFeedbackType& aFeedbackEnabled )

    {

    TPckg<TTouchFeedbackType> enabled( aFeedbackEnabled );

    SendReceive( EFBEnabledForDevice, TIpcArgs( &enabled ) );

    }

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

// 

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

//     

EXPORT_C void RTactileFeedback::PlayPreviewFeedback( TInt aLevel,

                                 TTouchLogicalFeedback aFeedback,

                                 TTouchFeedbackType aType )

    {

    SendReceive( EPlayPreviewFeedback, TIpcArgs( aLevel, 

                                                 aFeedback, 

                                                 aType ) );    

    }

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

// 

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

//     

EXPORT_C void RTactileFeedback::StartPreviewFeedback( TInt aLevel,

                                  TTouchContinuousFeedback aFeedback,

                                  TInt aIntensity,

                                  TTouchFeedbackType aType )

    {

    SendReceive( EStartPreviewFeedback, TIpcArgs( aLevel, aFeedback, 

                                                  aIntensity, aType ) );

    }

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

// 

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

//     

EXPORT_C void RTactileFeedback::ModifyPreviewFeedback( TInt aIntensity )

    {

    SendReceive( EModifyPreviewFeedback, TIpcArgs( aIntensity ) );

    }

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

// 

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

// 

EXPORT_C void RTactileFeedback::StopPreviewFeedback()

    {

    SendReceive( EStopPreviewFeedback );    

    }

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

// 

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

//      

TVersion RTactileFeedback::Version() const

    {

    return TVersion( KTactileFeedbackServerMajor, 

                     KTactileFeedbackServerMinor, 

                     KTactileFeedbackServerBuild );

    }