/*

* Copyright (c) 2002-2007 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:  Service starter implementation

*

*/

// INCLUDE FILES

#include "BTServiceStarter.h"

#include "BTSUDebug.h"

#include "BTSOPPController.h"

#include "BTSBIPController.h"

#include "BTSBPPController.h"

#include <Obexutils.rsg>

#include <obexutilsuilayer.h>

#include <obexutilsmessagehandler.h>

#include <btnotif.h>

#include <featmgr.h>

#include "BTSProgresstimer.h"

#include <hbdevicenotificationdialogsymbian.h>

#include <btservices/bluetoothdevicedialogs.h>

// CONSTANTS

// From BT SIG - Assigned numbers

const TUint KBTServiceOPPSending        = 0x1105;

const TUint KBTServiceDirectPrinting    = 0x1118;

const TUint KBTServiceImagingResponder  = 0x111B;

const TUint KBTProgressInterval         = 1000000;

_LIT(KSendingDialog,"com.nokia.hb.btdevicedialog/1.0");

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

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

// CBTServiceStarter::CBTServiceStarter

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

// might leave.

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

//

CBTServiceStarter::CBTServiceStarter() 

    : CActive( CActive::EPriorityStandard ),

      iBTEngDiscovery(NULL),

      iService( EBTSendingService ),

      iServiceStarted( EFalse ),

      iMessageServerIndex(0),

      iBytesSendWithBIP(0),

      iProgressDialogActive(EFalse),

      iUserCancel(EFalse), 

      iFeatureManagerInitialized(EFalse),

      iTriedBIP(EFalse),

      iTriedOPP(EFalse)

    {    

    CActiveScheduler::Add( this );

    }

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

// CBTServiceStarter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBTServiceStarter::ConstructL()

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::ConstructL()"));

    iDevice = CBTDevice::NewL();

//    iDialog = CObexUtilsDialog::NewL( this );

    iDeviceDialog = CHbDeviceDialogSymbian::NewL();

    iProgressDialog = CHbDeviceProgressDialogSymbian::NewL(CHbDeviceProgressDialogSymbian::EWaitDialog,this);

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    FLOG(_L("[BTSU]\t CBTServiceStarter::ConstructL() completed"));

    }

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

// CBTServiceStarter::NewL

// Two-phased constructor.

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

//

CBTServiceStarter* CBTServiceStarter::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CBTServiceStarter::~CBTServiceStarter()

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::Destructor()"));

    if ( iMessageServerIndex != 0 )

        {

        TRAPD( notUsedRetVal, TObexUtilsMessageHandler::DeleteOutboxEntryL( iMessageServerIndex ) );

        notUsedRetVal=notUsedRetVal;

        FTRACE(FPrint(_L("[BTSU]\t ~CBTServiceStarter() delete ob entry %d"), notUsedRetVal ) );

        }

    StopTransfer(KErrCancel); // Cancels active object

    delete iList;

    delete iDevice;

    delete iController;

    delete iBTEngDiscovery;

 //   delete iDialog;

    delete iDeviceDialog;

    delete iProgressDialog;

    if(iProgressTimer)

        {

        delete iProgressTimer;

        }

    if(iWaiter && iWaiter->IsStarted() )

        {

        iWaiter->AsyncStop();

        }

    delete iBTEngSettings;

    if ( iFeatureManagerInitialized )

        {

        FeatureManager::UnInitializeLib();

        }

    FLOG(_L("[BTSU]\t CBTServiceStarter::Destructor() completed"));

    }

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

// CBTServiceStarter::StartServiceL

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

//

void CBTServiceStarter::StartServiceL( TBTServiceType aService, 

                                       CBTServiceParameterList* aList,

                                       CActiveSchedulerWait* aWaiter )

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartServiceL()"));

	// Delete old list and take ownership of the new one

    //

	delete iList;

	iList = aList;

    if ( iServiceStarted )

        {

        User::Leave( KErrInUse );

        }

    if ( !ValidParameters( aService, aList ) )

        {

        User::Leave( KErrArgument );

        }	

    // Store the waiter pointer, a NULL value is also accepted

    //

    iWaiter = aWaiter;

    // Store the requested service

    //

    iService = aService;

    if( !iBTEngSettings )

        {

        iBTEngSettings = CBTEngSettings::NewL( this );

        }

    TBTPowerStateValue power = EBTPowerOff;

    User::LeaveIfError( iBTEngSettings->GetPowerState( power ) );

    TBool offline = EFalse;

    if( !power )

        {

        //offline = CheckOfflineModeL();

         offline = EFalse;

        }

    if( !offline )

        {

        FLOG(_L("[BTSU]\t CBTServiceStarter::StartServiceL() Phone is online, request temporary power on."));

		TurnBTPowerOnL( power );

        }

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartServiceL() completed"));

    }

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

// CBTServiceStarter::ControllerComplete

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

//

void CBTServiceStarter::ControllerComplete( TInt aStatus )

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::ControllerComplete()"));    

    TInt error;

    if ( iAllSend ) //stop transfer if everything is send

        {

        StopTransfer( aStatus );	      	        

        return;    

        }

    if(( aStatus==KErrNone || aStatus==EBTSNoError ) && 

        iState == EBTSStarterFindingBIP )

        {

        iBytesSendWithBIP=0;

        if( iProgressGetter )

            {

            iBytesSendWithBIP=iProgressGetter->GetProgressStatus();

            iProgressGetter=NULL;

            delete iController; 

            iController = NULL;            

            }

        if ( !iBTEngDiscovery )

            {

            TRAPD(err, iBTEngDiscovery = CBTEngDiscovery::NewL(this) );

            if (err != KErrNone )

                {

                StopTransfer(EBTSPuttingFailed);	      	

                return;

                }

            }

        error=iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(),

                               TUUID(KBTServiceOPPSending));	                 

        if( error == KErrNone )

	      	{

	      	iState = EBTSStarterFindingOPP;	

        	}

        else

        	{

        	StopTransfer(EBTSPuttingFailed);	      	

       		}		                           

        }

    else

        {

        StopTransfer( aStatus );	      	        

        }   

    FLOG(_L("[BTSU]\t CBTServiceStarter::ControllerComplete() completed"));

    }

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

// CBTServiceStarter::GetProgressStatus

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

//

TInt CBTServiceStarter::GetProgressStatus()

    {    

    if ( iProgressGetter )

        {

        return iProgressGetter->GetProgressStatus()+iBytesSendWithBIP;       

        }

    else

        {

        return iBytesSendWithBIP;

        }

    }

void CBTServiceStarter::UpdateProgressInfoL()

    {

    HBufC* key = HBufC::NewL(50);

    CleanupStack::PushL(key);

    HBufC* value = HBufC::NewL(50);

    CleanupStack::PushL(value);

    CHbSymbianVariantMap* map = CHbSymbianVariantMap::NewL();

    CleanupStack::PushL(map);

    TInt progress = GetProgressStatus();

    key->Des().Copy(_L("progressValue"));

    CHbSymbianVariant* progressvalue = CHbSymbianVariant::NewL(&progress, CHbSymbianVariant::EInt);

    map->Add(*key,progressvalue);

    key->Des().Copy(_L("currentFileIdx"));

    value->Des().AppendNum(iFileIndex);

    CHbSymbianVariant* currentFileIdx = CHbSymbianVariant::NewL(value, CHbSymbianVariant::EDes);

    map->Add(*key,currentFileIdx);

    TInt ret = iDeviceDialog->Update(*map);

    CleanupStack::PopAndDestroy(map);

    CleanupStack::PopAndDestroy(value);            

    CleanupStack::PopAndDestroy(key);

    if ( iProgressTimer )

        {

        iProgressTimer->Tickle();

        }

    }

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

// CBTServiceStarter::ValidParameters

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

//

TBool CBTServiceStarter::ValidParameters( 

    TBTServiceType aService, const CBTServiceParameterList* aList) const

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::ValidParameters()"));

    TBool result = EFalse;

    if ( aList != NULL )

        {

        switch ( aService )

            {

            case EBTSendingService:

                {

                // Sending service must have object or image parameters

                //

                if ( aList->ObjectCount() > 0 || aList->ImageCount() > 0 )

                    {

                    result = ETrue;

                    }

                break;

                }

            case EBTPrintingService:

                {

                // Printing service must have xhtml parameters

                //

                if ( aList->XhtmlCount() > 0 )

                    {

                    result = ETrue;

                    }       

                break;

                }

            case EBTObjectPushService:

                {

                // Sending service must have object or image parameters

                //

                if ( aList->ObjectCount() > 0 || aList->ImageCount() > 0 )

                    {

                    result = ETrue;

                    }      

                break;

                }

            default:

                {

                result = EFalse;

                break;

                }

            }

        }

    FTRACE(FPrint(_L("[BTSU]\t CBTServiceStarter::ValidParameters() completed with %d"), result ) );

    return result;

    }

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

// CBTServiceStarter::StartProfileSelectL

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

//

void CBTServiceStarter::StartProfileSelectL( TBTServiceType aService )

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL()"));    

    LaunchWaitNoteL();   

    iAllSend=EFalse;  

    iSendToBIPOnlyDevice = EFalse;

    if ( !iBTEngDiscovery )

        {

        iBTEngDiscovery = CBTEngDiscovery::NewL(this);

        }

    if ( !FeatureManager::FeatureSupported( KFeatureIdBtImagingProfile ) && (aService != EBTPrintingService) )

        {

        // If BTimagingProfile is disabled, use OPP instead.

        User::LeaveIfError( iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(), 

                                                                                       TUUID(KBTServiceOPPSending)));

        iState = EBTSStarterFindingOPP;  

        return;

        }

    switch ( aService  )

        {

        case EBTSendingService: // Find OPP

            {            

            if ( iList->ObjectCount() > 0 )  // We try to send files with OPP profile as long as it contains non-bip objects

                {

                FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() OPP"));    

                User::LeaveIfError( iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(), 

                                                                                TUUID(KBTServiceOPPSending)));

                iState = EBTSStarterFindingOPP;          

                }

            else if(iList->ObjectCount() == 0 && iList->ImageCount() > 0)

                {

                FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() BIP")); 

                User::LeaveIfError( iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(),

                                                                                TUUID(KBTServiceImagingResponder)));

                iState = EBTSStarterFindingBIP;

                }

            break;

            }

        case EBTPrintingService: // Find BPP

            {

            FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() BPP"));

            User::LeaveIfError( iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(),

                TUUID(KBTServiceDirectPrinting)));

            iState = EBTSStarterFindingBPP;            

            break;

            }

        case EBTObjectPushService: // Find BIP

            {

            FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() BIP"));

            User::LeaveIfError( iBTEngDiscovery->RemoteProtocolChannelQuery(iDevice->BDAddr(),

                TUUID(KBTServiceOPPSending)));

            iState = EBTSStarterFindingOPP;            

            break;

            }

        default:

            {

            FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() ERROR, unhandled case"));            

            break;

            }

        }

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileSelectL() completed"));

    }

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

// CBTServiceStarter::StartProfileL

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

//

void CBTServiceStarter::StartProfileL( TBTServiceProfile aProfile )

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileL()"));

    switch ( aProfile )

        {

        case EBTSBPP:

            {            

            iController = CBTSBPPController::NewL( this, iClientChannel, 

                                                   iDevice->BDAddr(), iList,

                                                   iBTEngDiscovery );

            break;

            }

        case EBTSOPP:

            {

            iController = CBTSOPPController::NewL( this, iClientChannel, 

                                                   iDevice->BDAddr(), iList );

            break;

            }

        case EBTSBIP:

            {

            iController = CBTSBIPController::NewL( this, iClientChannel, 

                                                   iDevice->BDAddr(), iList );

            break;

            }

        case EBTSNone:

        default:

            {

            FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileL() ERROR, unhandled case"));            

            break;

            }

        }

    FLOG(_L("[BTSU]\t CBTServiceStarter::StartProfileL() completed"));

    }

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

// CBTServiceStarter::LaunchWaitNoteL

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

//

void CBTServiceStarter::LaunchWaitNoteL()

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::LaunchWaitNoteL()"));

    if ( iService == EBTPrintingService )

        {

 //       iDialog->LaunchWaitDialogL( R_BT_PRINTING_WAIT_NOTE );

        }

    else

        {

        //       iDialog->LaunchWaitDialogL( R_BT_CONNECTING_WAIT_NOTE );

        _LIT(KConnectText, "Connecting...");

        iProgressDialog->SetTextL(KConnectText);

        iProgressDialog->ShowL();

        }    

    FLOG(_L("[BTSU]\t CBTServiceStarter::LaunchWaitNoteL() completed"));

    }

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

// CBTServiceStarter::CancelWaitNote

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

//

void CBTServiceStarter::CancelWaitNote()

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::CancelWaitNote()"));

  //  if ( iDialog )

  //      {

        //       TRAP_IGNORE( iDialog->CancelWaitDialogL() );

        if(iProgressDialog)

            {

            //This has to be tested

            iProgressDialog->Close();

            }

    //    }

    FLOG(_L("[BTSU]\t CBTServiceStarter::CancelWaitNote() completed"));

    }

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

// CBTServiceStarter::LaunchProgressNoteL

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

//

void CBTServiceStarter::LaunchProgressNoteL( MBTServiceProgressGetter* aGetter,

                                             TInt aTotalSize, TInt aFileCount)

    {

    FLOG(_L("[BTSU]\t CBTServiceStarter::LaunchProgressNoteL()"));

    (void) aTotalSize;

    if ( iService != EBTPrintingService )

        {    

        iProgressGetter = aGetter;     

        CancelWaitNote();