/*

* Copyright (c) 2002 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:  Declares Bluetooth device inquiry user interface class.

*

*/

// INCLUDE FILES

#include <avkon.hrh>            // AVKON components

#include <AknIconArray.h>

#include <aknlists.h>

#include <aknPopup.h>

#include <avkon.mbg>

#include <wlaninternalpskeys.h> // For WLAN state checking

#include <ctsydomainpskeys.h>

#include <AknNotiferAppServerApplication.h> 

#include <barsread.h>           // Resource reader

#include <BTNotif.rsg>          // Own resources

#include <bt_subscribe.h>

#include <btnotif.mbg>

#include <wlanplugin.mbg>       // Borrow WLan signal strenth bar to show RSSI  

#include <devui_const.h>

#include <btengutil.h>

#include <bluetoothuiutil.h>

#include "btninqui.h"           // Own class definition

#include "btNotifDebug.h"       // Debugging macros

#include "btnotifnameutils.h"

const TInt KBTAllPurposeBufferLength = 266;

const TInt KBTNotifNonPairedUsedDevicesMaxNumber= 5;

// RSSI value range: -127dB ~ +20dB

const TInt KRssiRangeOffset = 127 + 1;  // Offset for getting a non-zero positive value

const TInt KMinimumStrength = 1;

const TInt KMediumStrength = 53;

const TInt KHighStrength = 82;

const TUint32 ExcludePairedDeviceMask = 0x800000;

const TUint32 ResetExcludePairedDeviceMask = 0xFF7FFFFF;

_LIT(KBtnotifBmpFileName,"btnotif.mbm");

_LIT(KWLanBmpFileName,"wlanplugin.mif");

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

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

// CBTInqUI::CBTInqUI

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

// might leave.

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

//

CBTInqUI::CBTInqUI( MBTNDeviceSearchObserver* aObserver, 

        CBTNotifUIUtil* aUtil, 

        const TBTDeviceClass& aDesiredDevClass): 

        iUiUtil (aUtil),

        iEikonEnvRef( iUiUtil->LocalEikonEnv() ),

        iDevicesFound (EFalse),

        iBroughtForwards (EFalse),

        iDesiredDeviceClass (aDesiredDevClass),

        iSystemCancel (EFalse), 

        iPageForName ( EFalse ),

        iCurrentlyResolvingUnnamedDeviceIndex (0),

        iDevSearchObserver (aObserver)

    {

	iBTRegistryQueryState=ENoQuery;

	}

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

// CBTInqUI::ConstructL

// Symbian 2nd phase constructor can leave.

// Creates first device list (not shown yet) and initializes 

// couple of member variables with default values.

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

//

void CBTInqUI::ConstructL()

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::ConstructL()"));

    // Read default device names to an array

    iDefaultDeviceNamesArray = iEikonEnvRef.ReadDesCArrayResourceL( R_BT_DEFAULT_DEVICE_NAMES );

    // create the timer

    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);

    // Create device array

    //

    iDeviceListRows = new(ELeave) CDesCArrayFlat(1);

    iPairedDevicesArray = new (ELeave) CBTDeviceArray(1);

    iLastUsedDevicesArray = new(ELeave) CBTDeviceArray(1);

    iLastSeenDevicesArray = new(ELeave) CBTDeviceArray(1);

	iAdjustedUsedDeviceArray = new(ELeave) CBTDeviceArray(1);	

	iDevMan=CBTEngDevMan::NewL(this);

	iExcludePairedDevices = iDesiredDeviceClass.DeviceClass() & ExcludePairedDeviceMask ? 

                            ETrue : EFalse;	

    if ( iExcludePairedDevices )

        {         

        FLOG (_L("[BTNOTIF]\t CBTInqUI::ConstrucL Excluding paired devices"));

        iDesiredDeviceClass = iDesiredDeviceClass.DeviceClass() & ResetExcludePairedDeviceMask;

        }

    // Retrieve paired devices to a local array

    RetrievePairedDevices();

    FLOG(_L("[BTNOTIF]\t CBTInqUI::ConstructL() completed"));

    }

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

// CBTInqUI::RetrieveUsedDevices- Substitute

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

//

void CBTInqUI::RetrieveUsedDevices()

	{

	FLOG(_L("[BTNOTIF]\t CBTInqUI::RetrieveUsedDevicesL()"));	

	TBTRegistrySearch searchPattern;

	searchPattern.FindAll();

    //Ignore this error. Continue device search.

	TInt err=iDevMan->GetDevices( searchPattern, iLastUsedDevicesArray );	

	if(err)

	    {

	    TRAP_IGNORE(AdjustDeviceArrayL(iAdjustedUsedDeviceArray));

	    DoDeviceFrontListSelection();

	    FTRACE(FPrint(_L("[BTNOTIF]\t CBTInqUI: get useddevice err %d"), err));  

	    }

	else

	    {

	    iBTRegistryQueryState=EQueryUsed;

	    }

	FLOG(_L("[BTNOTIF]\t CBTInqUI::RetrieveUsedDevicesL() returned"));

	}

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

// CBTInqUI::RetrievePairedDevices

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

void CBTInqUI::RetrievePairedDevices()

    {

	FLOG(_L("[BTNOTIF]\t CBTInqUI::RetrievePairedDevicesL()"));

	TBTRegistrySearch searchPattern;

    searchPattern.FindBonded();

	TInt err= iDevMan->GetDevices( searchPattern, iPairedDevicesArray );	

	FTRACE(FPrint(_L("[BTNOTIF]\t CBTInqUI: get paireddevice err %d"), err));  

	if(err)

	    {

        //Next: try to get used devices

	    RetrieveUsedDevices();

	    }

	else

	    {

	    iBTRegistryQueryState=EQueryPaired;	

	    }

	FLOG(_L("[BTNOTIF]\t CBTInqUI::RetrievePairedDevicesL() returned"));

    }

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

// CBTInqUI::HandleGetDevicesComplete

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

//

void CBTInqUI::HandleGetDevicesComplete(TInt aErr, CBTDeviceArray* /*aDeviceArray*/)

	{

	FTRACE(FPrint(_L("[BTNOTIF]\t CBTInqUI::HandleGetDevicesComplete() err: %d"), aErr));	

	(void) aErr;

	switch(iBTRegistryQueryState)

		{

		case EQueryPaired:

		    // If a device is paired in Just Works model but without user awareness,

		    // This device won't be shown in UI paired view, so we have to 

		    // remove it from this array so that it will be shown to user

		    // in the last used device list.

		    for (int i = iPairedDevicesArray->Count() - 1; i >= 0; --i )

		        {

		        if ( !IsUserAwarePaired( iPairedDevicesArray->At( i )->AsNamelessDevice() ) )

		            {

		            delete iPairedDevicesArray->At( i );

		            iPairedDevicesArray->Delete( i );

		            }

		        }

			RetrieveUsedDevices();

			break;

		case EQueryUsed:

			// fill in the list of last seen devices, so it can be shown

			TRAP_IGNORE(AdjustDeviceArrayL(iAdjustedUsedDeviceArray));

			DoDeviceFrontListSelection();

			break;

		default:

			break;

		}

	FLOG(_L("[BTNOTIF]\t CBTInqUI::HandleGetDevicesComplete() Complete"));		

	}

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

// Destructor

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

//

CBTInqUI::~CBTInqUI()

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::~CBTInqUI()"));

    if( iBroughtForwards )

        {

        iEikonEnvRef.BringForwards(EFalse);

        iBroughtForwards = EFalse;

        }

    if( iPairedDevicesArray ) 

        {

        iPairedDevicesArray->ResetAndDestroy();	            

        delete iPairedDevicesArray; 

        }

    if( iLastUsedDevicesArray ) 

        {  

        iLastUsedDevicesArray->ResetAndDestroy();	    

        delete iLastUsedDevicesArray; 

        }       

    if( iLastSeenDevicesArray ) 

        {  

        iLastSeenDevicesArray->ResetAndDestroy();

        delete iLastSeenDevicesArray; 

        }

    iLastSeenDevicesNameComplete.Close();

    if( iAdjustedUsedDeviceArray )

        {

        iAdjustedUsedDeviceArray->ResetAndDestroy();

        delete iAdjustedUsedDeviceArray; 

        }

    if( iDefaultDeviceNamesArray )

        {

        iDefaultDeviceNamesArray->Reset();

        delete iDefaultDeviceNamesArray;

        }

	delete iDevMan;    

    delete iDeviceListBox;

    delete iDeviceListRows;

	delete iPeriodicTimer;	

    FLOG(_L("[BTNOTIF]\t CBTInqUI::~CBTInqUI() completed"));

    }

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

// CBTInqUI::Cancel

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

//

void CBTInqUI::Cancel()

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::Cancel()"));  

    iSystemCancel = ETrue;

    if(iDevMan)

 	   {

 	   iDevMan->Cancel();  	

  	   }

    if( iSearchFilterPopupList )

        {

        iSearchFilterPopupList->CancelPopup();

        }

    if(iPeriodicTimer)

        {

        iPeriodicTimer->Cancel();

        }

    RemoveScanner();

    InquiryComplete(KErrCancel);

    FLOG(_L("[BTNOTIF]\t CBTInqUI::Cancel() completed"));

    }

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

// CBTInqUI::DisplayDevicesFrontListL

// Display last seen devices popuplist

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

//

void CBTInqUI::DisplayDevicesFrontListL()

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::DisplayDevicesFrontListL()"));

    if ( iAdjustedUsedDeviceArray->Count() <= 0 )

        {

        SelectSearchCategoryL();

        return;

        }

    if( !iBroughtForwards )

        {

        iEikonEnvRef.BringForwards(ETrue); // Destructor will release this later on

        iBroughtForwards = ETrue;

        }

    // Create the devices popuplist

    CreatePopupListL( R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT , R_BT_LAST_USED_DEVS_POPUP_TITLE );

    // Add devices into device list.

    for( TInt index = 0; index < iAdjustedUsedDeviceArray->Count(); index++ )

    	{        

   	    AddToDeviceListBoxL ( iAdjustedUsedDeviceArray->At(index) );  

        }  

    // Add "more devices" command as first item of list

    HBufC* formatString = HBufC::NewLC( KBTAllPurposeBufferLength );

    formatString->Des().Copy( TPtrC(KDeviceIconFormatTable[EDeviceIconBlank].iFormat ) );

    HBufC* moreDevicesString = iEikonEnvRef.AllocReadResourceLC( R_BT_MORE_DEVICES_ITEM );

    formatString->Des().Append( *moreDevicesString );

    CleanupStack::PopAndDestroy(); // moreDevicesString

    iDeviceListRows->InsertL( 0, *formatString );

    CleanupStack::Pop(); // formatString

    // Launch popup list and wait for user input 

    AllowDialerAndAppKeyPress( EFalse );

    TInt popupRetVal = iDevicePopupList->ExecuteLD();    

    iDevicePopupList = NULL;   

    AllowDialerAndAppKeyPress( ETrue );

    if( !popupRetVal )

        { 

        // query cancelled by user or system, complete device search:

        iDevSearchObserver->NotifyDeviceSearchCompleted(KErrCancel);

        return;

        }

    TInt currentDeviceIndex = iDeviceListBox->CurrentItemIndex();

    // Delete device list box and reset device items array

    delete iDeviceListBox;

    iDeviceListBox = NULL;

    iDeviceListRows->Reset();

    if( currentDeviceIndex > 0 ) // User selected "a used device"

        {

        HandleDeviceSelectionL( iAdjustedUsedDeviceArray->At( currentDeviceIndex - 1 ) );   

        return;

        }

    // user selected more devices.

    SelectSearchCategoryL();

    FLOG(_L("[BTNOTIF]\t CBTInqUI::DisplayDevicesFrontListL() completed"));

    }

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

// CBTInqUI::DeviceSearchUiL

// Execute bluetooth device search/inquiry.

// Parameters:

//  OUT: aDevice     - selected device after inquiry

//  IN:  aObexOnly   - flag if OBEX capable devices is requested

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

//

void CBTInqUI::DeviceSearchUiL()

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::DeviceSearchUiL()"));

    TSearchFlowState searchFlow;

    TInt err;

    AllowDialerAndAppKeyPress( EFalse );

    do

        {

        searchFlow = InitInquiryL(err);

        } while (searchFlow == ESearchAgain);

    if (searchFlow == ESearchCompleted)

        {

        // search completed caused by either user cancel or failure

        iDevSearchObserver->NotifyDeviceSearchCompleted(err);

        AllowDialerAndAppKeyPress( ETrue );

        return;

        }

    FLOG(_L("[BTNOTIF]\t CBTInqUI, Displaying devices already found"));

    TInt keypress(0);

    // Show devices popup list for received devices while

    // inquiry is still active and list may be updated.

    if( !iInquiryComplete )

        {

        CreatePopupListL( R_BT_SOFTKEYS_SELECT_STOP, R_BT_SEARCH_DEVS_POPUP_TITLE );

        // Set animation

        iDevicePopupList->Heading()->SetHeaderAnimationL( R_BT_ANIMATION_FOR_POPUPLIST );

        // Launch popup list and wait for user input

        keypress = iDevicePopupList->ExecuteLD();    

        iDevicePopupList = NULL;

        }

    // If Cancel() is called while DoInquery() is still running,

    // such as taking out MMC while bt devices discovery or user pressed redkey.                 

    // In such cases, We need to dismiss anything and function returns immediately.

    //

    if (iSystemCancel )

        {

        FLOG(_L("[BTNOTIF]\t inquiry was canncelled by the system!"));

        iSystemCancel = EFalse;

        AllowDialerAndAppKeyPress( ETrue );

        iDevSearchObserver->NotifyDeviceSearchCompleted(KErrCancel);

        return;

        }

    // Cancel inquiry

    RemoveScanner();

    // Store the highlighted device index and destroy list box

    iHighLightedItemIndex = 0;

    if( iDeviceListBox )

        {

        iHighLightedItemIndex = iDeviceListBox->CurrentItemIndex();

        delete iDeviceListBox;

        iDeviceListBox = NULL;

        }

    // user selected a device during active inquiry

    if (keypress)

        {

        AllowDialerAndAppKeyPress( ETrue );

        HandleDeviceSelectionL( iLastSeenDevicesArray->At( iHighLightedItemIndex ) );

        return;

        }

    // Error encountered in inquiry

    if (iInquiryStatus)

        {

        AllowDialerAndAppKeyPress( ETrue );

        iDevSearchObserver->NotifyDeviceSearchCompleted(iInquiryStatus);

        return;

        }

    // Inquiry completed, show final device list 

    FLOG(_L("[BTNOTIF]\t CBTInqUI::DeviceSearchUiL Displaying final devicelist"));          

    CreatePopupListL( R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT, R_BT_FOUND_DEVS_POPUP_TITLE );

    //cancel iPeriodicTimer after the final list is shown

    iPeriodicTimer->Cancel();

    User::ResetInactivityTime();

    // Set highlight on top of same device as it was in previous popuplist

    if( iHighLightedItemIndex >= 0 )

        {

        iDeviceListBox->HandleItemAdditionL();

        iDeviceListBox->SetCurrentItemIndex(iHighLightedItemIndex);

        }

    // Launch popup list and wait for user input

    keypress = iDevicePopupList->ExecuteLD();

    iDevicePopupList = NULL;

    AllowDialerAndAppKeyPress( ETrue );

    // If dialog is cancelled by system:

    if( !keypress)

        {

        iDevSearchObserver->NotifyDeviceSearchCompleted(KErrCancel);

        return;

        }

    // Get user selection

    TInt index = iDeviceListBox->CurrentItemIndex();

    delete iDeviceListBox;

    iDeviceListBox = NULL;

    HandleDeviceSelectionL( iLastSeenDevicesArray->At( index ) );

    FLOG(_L("[BTNOTIF]\t CBTInqUI::DeviceSearchUiL() complete"));    

    }

TSearchFlowState CBTInqUI::InitInquiryL(TInt& aReason)

    {

    FLOG(_L("[BTNOTIF]\t CBTInqUI::InitInquiryL"));

    if (IsActiveVoIPOverWLAN())

        {

        iUiUtil->ShowInfoNoteL( R_BT_NO_DEVICE_DISCOVERY_VOIP, ECmdBTnotifUnavailable );

        aReason = KErrInUse;

        return ESearchCompleted;

        }

    // starting  the timer

    iPeriodicTimer->Cancel();

    iPeriodicTimer->Start(KPeriodicTimerInterval4Sec, KPeriodicTimerInterval4Sec, 

                        TCallBack(PeriodicTimerCallBack, this));

    // Prepare for using hostresolver to search devices 

    CreateScannerL();

    iInquiryStatus = KErrCancel; // Give a initial value (for end key handling)

    iDevicesFound = EFalse;

    iInquiryComplete = EFalse;

    iSystemCancel = EFalse;   

    // Show wait note until dialog is dismissed by inquirey result callbacks or user cancel

    TInt ret = iUiUtil->ShowWaitDlgL( R_BT_SEARCHING_DEVICES_NOTE );

    // If user cancels searching, ret will be KerrNone.  

    // According to Description of Eikdialog, ShowWaitDlgL() returns zero 

    // if it was the cancel button (@c EEikBidCancel). 

    if( ret == KErrNone || iSystemCancel )

        {

        FLOG(_L("[BTNOTIF]\t CBTInqUI, User cancelled waiting note"));

        RemoveScanner();

        aReason = KErrCancel;

        return ESearchCompleted;

        }

     if( !iDevicesFound ) // No devices found at all

         {

         FLOG(_L("[BTNOTIF]\t CBTInqUI no devices found at all"));

         RemoveScanner(); // Cancel inquiry

         if( iInquiryStatus != KErrNone )

             {

             aReason = iInquiryStatus;

             return ESearchCompleted;

             }

         // Show try again query

         TBool keypress(0);

         keypress = iUiUtil->ShowQueryL( KErrNone, R_BT_TRY_AGAIN_QUERY, ECmdBTnotifUnavailable );

         if( !keypress ) // User has not requested new inquiry

             {