/*

* Copyright (c) 2010 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:  class for searching BT devices

*

*/

#include "basicdevdiscoverer.h"

#include <btservices/devdiscoveryobserver.h>

#include "btserviceutilconsts.h"

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

// CBasicDevDiscoverer::CBasicDevDiscoverer

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

//

CBasicDevDiscoverer::CBasicDevDiscoverer( MDevDiscoveryObserver& aObserver )

    : iObserver( aObserver )

    {

    }

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

// CBasicDevDiscoverer::ConstructL

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

//

void CBasicDevDiscoverer::ConstructL()

    {

    User::LeaveIfError( iSocketServer.Connect() );

    iActive = CBtSimpleActive::NewL( *this, BtServiceUtil::EBluetoothInquiry );

    }

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

// CBasicDevDiscoverer::NewL

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

//

CBasicDevDiscoverer* CBasicDevDiscoverer::NewL( MDevDiscoveryObserver& aObserver )

    {

    CBasicDevDiscoverer* self = new (ELeave) 

            CBasicDevDiscoverer( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CBasicDevDiscoverer::

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

//

CBasicDevDiscoverer::~CBasicDevDiscoverer()

    {

    delete iActive;

    Reset();

    iSocketServer.Close();

    iDevices.Close();

    }

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

// CBasicDevDiscoverer::SetObserver

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

//

void CBasicDevDiscoverer::SetObserver( MDevDiscoveryObserver& aObserver )

    {

    iObserver = aObserver;

    }

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

// CBasicDevDiscoverer::

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

//

void CBasicDevDiscoverer::Cancel()

    {

    iActive->Cancel();

    iHostResolver.Close();

    iDevices.ResetAndDestroy();

    }

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

// CBasicDevDiscoverer::

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

//

void CBasicDevDiscoverer::DiscoverDeviceL(TBTMajorDeviceClass aDeviceClass )

    {

    // This class supports only one request at the time:

    if ( iActive->IsActive() )

        {

        User::Leave( KErrInUse );

        }

    Reset();

    iMajorDeviceClassFilter = aDeviceClass;

    _LIT( KLinkMgrDes, "BTLinkManager" );

    // Associate with bluetooth Link Manager.

    TProtocolName protocol( KLinkMgrDes );

    TProtocolDesc pInfo;

    User::LeaveIfError( iSocketServer.FindProtocol( protocol, pInfo));

    User::LeaveIfError( iHostResolver.Open(iSocketServer, 

            pInfo.iAddrFamily, pInfo.iProtocol));

    iActive->SetRequestId( BtServiceUtil::EBluetoothInquiry );

    iInquirySockAddr.SetAction( KHostResInquiry + KHostResEir + KHostResIgnoreCache );

    // We always do Generic Inquiry.

    // Limited Inquiry could be added here in future on business need.

    iInquirySockAddr.SetIAC(KGIAC);

    iHostResolver.GetByAddress( iInquirySockAddr, iEntry, iActive->RequestStatus() );

    iActive->GoActive();

    }

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

// CBasicDevDiscoverer::RequestCompletedL

// Inform caller for received device and issue next EIR/Name request

// if the request was successful.

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

//

void CBasicDevDiscoverer::RequestCompletedL( CBtSimpleActive* aActive, TInt aStatus )

    {

    TInt errToObserver( aStatus );

    // position in array iDevices: the device item the observer will be notified of.

    TInt devToNotify ( KErrNotFound ); 

    if ( aActive->RequestId() == BtServiceUtil::EBluetoothInquiry )

        {

        if ( aStatus == KErrNone )

            {

            TInt pos = HandleInquiryResultL();

            // continue to inquiry for more devices in range

            iHostResolver.Next( iEntry, iActive->RequestStatus() );

            iActive->GoActive();

            if ( pos > KErrNotFound && iDevices[pos]->iName.Length() > 0 )

                {

                devToNotify = pos;

                }

            }

        else if( iDevices.Count() > 0 )

            {

            // an error from inquiry operation. 

            // we move to next step to get device names if some devices have been

            // found but without a name.

            iPagingNamePos = iDevices.Count() - 1;

            aActive->SetRequestId( BtServiceUtil::EBluetoothPageDeviceName );

            PageNextDeviceName();

            }

        }

    else if ( aActive->RequestId() ==  BtServiceUtil::EBluetoothPageDeviceName )

        {

        errToObserver = KErrNone;

        devToNotify = iPagingNamePos;

        // the name in iEntry was reset before paging operation, so we

        // can rely on this length() at this time:

        if ( aStatus == KErrNone && iEntry().iName.Length() > 0 )

            {

            iDevices[iPagingNamePos]->iName = iEntry().iName;

            }

            // the return error is not checked here. We continue to page the rest

            // device names.

            --iPagingNamePos;

            PageNextDeviceName();

        }

    // request ID is BtServiceUtil::EAsyncNotifyDeviceSearchCompleted

    else 

        {

        iObserver.HandleDiscoveryCompleted( errToObserver );

        return;

        }

    // AO not active means that this is neither inquiring nor paging name.

    // Schedule an operation completion callback:

    if ( !iActive->IsActive() && 

            aActive->RequestId() != BtServiceUtil::EAsyncNotifyDeviceSearchCompleted )

        {

        // We inform the client of operation completion asynchronously, so that

        // we will not end up with problems, e.g., invalid memory,

        // if the client issues more request in the callback context.

        aActive->SetRequestId( BtServiceUtil::EAsyncNotifyDeviceSearchCompleted );

        aActive->RequestStatus() = KRequestPending;

        TRequestStatus* sta = &aActive->RequestStatus();

        User::RequestComplete( sta, errToObserver );

        aActive->GoActive();

        }

    // This could be possible in both inquiry and paging operations.

    if ( devToNotify > KErrNotFound )

        {

        // This device record is not used any more after we have informed client.

        // Extract it and push to cleanup for detroy.

        // This is to prevent peak memory usage in case of a great number of 

        // devices being in range.

        CDeviceSearchRecord* rec = iDevices[devToNotify];

        iDevices.Remove( devToNotify );

        CleanupStack::PushL( rec );

        iObserver.HandleNextDiscoveryResultL( rec->iAddr, rec->iName );

        CleanupStack::PopAndDestroy( rec );

        }

    }

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

// CBasicDevDiscoverer::DoCancelRequest

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

//

void CBasicDevDiscoverer::CancelRequest( TInt aId )

    {

    // host resolver needs to be cancelled.

    // For request BtServiceUtil::EAsyncNotifyDeviceSearchCompleted, we 

    // are doing self-completing. Thus, nothing is needed now.

    if ( aId == BtServiceUtil::EBluetoothInquiry || 

         aId == BtServiceUtil::EBluetoothPageDeviceName )

        {

        iHostResolver.Cancel();

        }

    }

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

// CBasicDevDiscoverer::HandleError

// Inform UI from error occured.

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

//

void CBasicDevDiscoverer::HandleError( CBtSimpleActive* aActive, TInt aError )

    {

    // We might have issued an request to Host Resolver in RequestCompleted().

    // Cancel AO just in case:

    aActive->Cancel();

    Reset();

    // We cannot proceed more. Inform client:

    iObserver.HandleDiscoveryCompleted( aError );

    }

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

// CBasicDevDiscoverer::

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

//

void CBasicDevDiscoverer::PageNextDeviceName()

    {

    // reset the name in entry so that previous result will

    // not propogate if the next paging operation fails.

    iEntry().iName.Zero();

    for (; iPagingNamePos > -1; --iPagingNamePos )

        {

        // Get the next in-range device that has no device name yet 

        // This is practically meaning that the device would be

        // < v2.1

        if( iDevices[iPagingNamePos]->iName.Length() == 0 )

            {

            iInquirySockAddr.SetAction( KHostResName + KHostResIgnoreCache );

            TBTDevAddr btaddr = iDevices[iPagingNamePos]->iAddr.BTAddr();

            iInquirySockAddr.SetBTAddr( iDevices[iPagingNamePos]->iAddr.BTAddr() );

            iInquirySockAddr.SetIAC(KGIAC);

            iHostResolver.GetByAddress( iInquirySockAddr, iEntry, iActive->RequestStatus() );

            iActive->GoActive();

            break;

            }

        }

    }

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

// CBasicDevDiscoverer::HandleInquiryResultL

// Inform of properties of the found BTdevice,   

// which passes the search filter. Its name would be retrived 

// later if not contained by the first round of inquiry.   

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

//

TInt CBasicDevDiscoverer::HandleInquiryResultL()

    {

    TInquirySockAddr& sa = TInquirySockAddr::Cast( iEntry().iAddr );

    // parse the inquiry result if this device passes the filters:

    if ( iMajorDeviceClassFilter == EMajorDeviceMisc 

         || sa.MajorClassOfDevice() == iMajorDeviceClassFilter )

        {

        CDeviceSearchRecord* record = NewInstanceL( sa );

        CleanupStack::PushL( record );

        iDevices.InsertL(record, 0 );

        CleanupStack::Pop( record );

        TBTDeviceName devName;

        TBluetoothNameRecordWrapper eir( iEntry() );

        TInt length = eir.GetDeviceNameLength();

        TBool isComplete( EFalse );

        if( length > 0 )

            {

            User::LeaveIfError( eir.GetDeviceName( record->iName, isComplete) );

            }

        return 0;

        }

    return KErrNotFound;

    }

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

// CBasicDevDiscoverer::CompleteDiscovery

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

//

CDeviceSearchRecord* CBasicDevDiscoverer::NewInstanceL( 

        const TInquirySockAddr& aAddr, const TDesC& aName )

    {

    CDeviceSearchRecord* record = new (ELeave) CDeviceSearchRecord();

    record->iAddr = aAddr;

    record->iName = aName;

    return record;

    }

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

// CBasicDevDiscoverer::Reset

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

//

void CBasicDevDiscoverer::Reset()

    {

    // Free the cache of host Resolver.

    iHostResolver.Close();

    // Clean previous in-range devices whose proximity status

    // may have been changed.

    iDevices.ResetAndDestroy();

    }

// End of File