/*
* Copyright (c) 2005-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:  Observer voice headset key presses
*
*/


#include "vcmanagervoiceheadsetlauncher.h"
#include "rubydebug.h"
#include <apgcli.h>
#include <apgtask.h>
#include <apacmdln.h>
#include <remconinterfaceselector.h>
#include <RemConCallHandlingTarget.h>
#include <voiceuidomainpskeys.h>
#include <vuivoicerecogdefs.h>
#include <ctsydomainpskeys.h>
#include <coreapplicationuisdomainpskeys.h>

// CONSTANTS

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

// -----------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::CVCommandManagerVoiceHeadSetLauncher
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVCommandManagerVoiceHeadSetLauncher::CVCommandManagerVoiceHeadSetLauncher() 
    {
    }

// -----------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CVCommandManagerVoiceHeadSetLauncher::ConstructL" );
    iSelector = CRemConInterfaceSelector::NewL();
    iCallHandlingTarget = CRemConCallHandlingTarget::NewL( *iSelector, *this );
    // Connect to Remote Control server as target. After succesfull call
    // client is ready to receive commands. Call this method only once in a
    // process.
    iSelector->OpenTargetL();
    }

// -----------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVCommandManagerVoiceHeadSetLauncher* CVCommandManagerVoiceHeadSetLauncher::NewL()
    {
    CVCommandManagerVoiceHeadSetLauncher* self = new( ELeave ) CVCommandManagerVoiceHeadSetLauncher;    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

    
// Destructor
CVCommandManagerVoiceHeadSetLauncher::~CVCommandManagerVoiceHeadSetLauncher()
    {
    RUBY_DEBUG0( "CVCommandManagerVoiceHeadSetLauncher::~CVCommandManagerVoiceHeadSetLauncher - START" );
    
    // iCallHandlingTarget will be destroyed when iSelector is destroyed.  
    delete iSelector;
    iProperty.Close();
    
    RUBY_DEBUG0( "CVCommandManagerVoiceHeadSetLauncher::~CVCommandManagerVoiceHeadSetLauncher - EXIT" );
    }


// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::AnswerCall
// ---------------------------------------------------------------------------
//    
void CVCommandManagerVoiceHeadSetLauncher::AnswerCall()
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtAnswerCall, KErrNone );
    User::WaitForRequest( response );
    }
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::AnswerCall
// ---------------------------------------------------------------------------
//    
void CVCommandManagerVoiceHeadSetLauncher::AnswerEndCall()
    {
    RUBY_DEBUG0( "" );
    iProperty.Set( KPSUidVoiceUiAccMonitor, KVoiceUiAccessoryEvent, KVoiceUiShortPressEvent );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtAnswerEnd, KErrNone );
    User::WaitForRequest( response );
    }
    
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::EndCall
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::EndCall()
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response,  ERemConExtEndCall, KErrNone );
    User::WaitForRequest( response );
    }
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::LastNumberRedial
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::LastNumberRedial()
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtLastNumberRedial, KErrNone );
    User::WaitForRequest( response );
    }
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::VoiceDial
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::VoiceDial( const TBool /*aActivate*/ )
    {
    RUBY_DEBUG0( "" );
    if ( GetAutoLockValue() > EAutolockOff )
        {
        TRemConExtCmdSource source;
        iCallHandlingTarget->GetCommandSourceInfo( source );
        
        if ( source == ERemConExtCmdSourceBluetooth )
            {
            TRAP_IGNORE( LaunchVoiceUiL( ETrue ) );
            }
        }
    else
        {
        TRAP_IGNORE( LaunchVoiceUiL( EFalse ) );
        }
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtVoiceDial, KErrNone );
    User::WaitForRequest( response );
    }

// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::DialCall
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::DialCall( const TDesC8& /*aTelNumber*/ )
    {
    RUBY_DEBUG0( "CVCommandManagerVoiceHeadSetLauncher::DialCall" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtDialCall, KErrNone );
    User::WaitForRequest( response );
    }    
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::MultipartyCalling
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::MultipartyCalling( const TDesC8& /*aData*/ )
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExt3WaysCalling, KErrNone );
    User::WaitForRequest( response );
    }
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::GenerateDTMF
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::GenerateDTMF( const TChar /*aChar*/ )
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtGenerateDTMF, KErrNone );
    User::WaitForRequest( response );
    }
    
// ---------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::SpeedDial
// ---------------------------------------------------------------------------
//
void CVCommandManagerVoiceHeadSetLauncher::SpeedDial( const TInt /*aIndex*/ )
    {
    RUBY_DEBUG0( "" );
    TRequestStatus response( KErrNone );
    iCallHandlingTarget->SendResponse( response, ERemConExtSpeedDial, KErrNone );    
    User::WaitForRequest( response );
    }

    
// ---------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::LaunchVoiceUiL
// ---------------------------------------------------------
//     
void CVCommandManagerVoiceHeadSetLauncher::LaunchVoiceUiL( TBool aDeviceLockMode )
    {
    RUBY_DEBUG_BLOCK( "" );
    
    // Check that phone or video call is not currently active
    TInt state = CheckCallState();
    if ( ( state == EPSCTsyCallStateNone ||
           state == EPSCTsyCallStateUninitialized ||
           state == KErrUnknown ) && !IsVideoCall() )
        {
        TApaTaskList apaTaskList( CCoeEnv::Static()->WsSession() );
        TApaTask apaTask = apaTaskList.FindApp( KVoiceUiUID );

        if ( apaTask.Exists() )
            {
            apaTask.BringToForeground();
            
            iProperty.Set( KPSUidVoiceUiAccMonitor, KVoiceUiAccessoryEvent, KVoiceUiLongPressEvent );
            }
        else
            {
            RApaLsSession apaLsSession;
            User::LeaveIfError( apaLsSession.Connect() );
            CleanupClosePushL(apaLsSession);
            
            TApaAppInfo appInfo;
            User::LeaveIfError( apaLsSession.GetAppInfo( appInfo, KVoiceUiUID ) );
            
            TFileName appName = appInfo.iFullName;
            CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();

            apaCommandLine->SetExecutableNameL( appName );
            apaCommandLine->SetCommandL( EApaCommandRunWithoutViews );
            
            if ( aDeviceLockMode )
                {
                // Command line parameters
                apaCommandLine->SetTailEndL( KVoiceUiMode );
                }
            
            User::LeaveIfError ( apaLsSession.StartApp( *apaCommandLine ) );
            CleanupStack::PopAndDestroy( apaCommandLine );

            CleanupStack::PopAndDestroy(&apaLsSession);
            }    
        }
    }
    
// ---------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::CheckCallState
// ---------------------------------------------------------
//
TInt CVCommandManagerVoiceHeadSetLauncher::CheckCallState()
    {
    RUBY_DEBUG0( "START" );
    
    TInt callState;
    TInt err = RProperty::Get( KPSUidCtsyCallInformation,
                               KCTsyCallState,
                               callState );
    if ( err == KErrNotFound )
        {
        callState = KErrNotFound;
        }
    
    RUBY_DEBUG0( "EXIT" );
    
    return callState;    
    }    
    
// -----------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::IsVideoCall 
// -----------------------------------------------------------------------------
//
TBool CVCommandManagerVoiceHeadSetLauncher::IsVideoCall() 
    {
    RUBY_DEBUG0( "START" );
    
    TInt callType;
    RProperty::Get( KPSUidCtsyCallInformation,
                    KCTsyCallType, 
                    callType );// Ignore errors  

    RUBY_DEBUG0( "EXIT" );

    return callType == EPSCTsyCallTypeH324Multimedia;
    }

// -----------------------------------------------------------------------------
// CVCommandManagerVoiceHeadSetLauncher::GetAutoLockValue 
// -----------------------------------------------------------------------------
//
TInt CVCommandManagerVoiceHeadSetLauncher::GetAutoLockValue()
    {
    RUBY_DEBUG0( "CVCommandManagerVoiceHeadSetLauncher::GetAutoLockValue START" );
  
    TInt autoLockValue;
    TInt err = RProperty::Get( KPSUidCoreApplicationUIs,
                               KCoreAppUIsAutolockStatus,
                               autoLockValue );
    if ( err == KErrNotFound )
        {
        autoLockValue = KErrNotFound;
        }
        
    RUBY_DEBUG0( "CVCommandManagerVoiceHeadSetLauncher::GetAutoLockValue EXIT" );
    
    return autoLockValue;
    }
    
//  End of File