/*

* Copyright (c) 2008 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:  This is the implementation of application class

 *

*/

#include <btdevice.h>

#include <bt_sock.h>

#include "hidsdpclient.h"

#include "bthiddevice.h"

#include "hidsdpobserver.h"

#include "bthidtypes.h"

#include "bthidserver.pan"

#include "descriptorlistparser.h"

class TServiceAttribute

    {

public:

    TSdpAttributeID iID;

    };

// HID Service Attributes

static const TServiceAttribute gHIDServiceAttributes[] =

    {

        {

        KHIDAttrDevRelNum

        },

        {

        KHIDAttrDevSubClass

        },

        {

        KHIDAttrCountryCode

        },

        {

        KHIDAttrVirtuallyCabled

        },

        {

        KHIDAttrReconnectInitiate

        },

        {

        KHIDAttrDescriptorList

        },

        {

        KHIDAttrProfileVersion

        },

        {

        KHIDAttrNormallyConnectable

        }

    };

// HID Service Attribute count 

static const TUint gHIDServAttrCount = sizeof(gHIDServiceAttributes) / sizeof(TServiceAttribute);

// PnP Service Attributes

static const TServiceAttribute gBTPnPServiceAttributes[] =

    {

        {

        KPnPAttrVendorID

        },

        {

        KPnPAttrProductID

        }

    };

// PnP Service Attribute count 

static const TUint gBTPnPAttrCount = sizeof(gBTPnPServiceAttributes)

        / sizeof(TServiceAttribute);

// Bit Mask flags for the mandatory fields value

const TUint KDevSubClassMandFlag = 1;

const TUint KCountryCodeMandFlag = 2;

const TUint KVirtuallyCabledMandFlag = 4;

const TUint KReconnectInitMandFlag = 8;

const TUint KDescriptorListMandFlag = 16;

const TUint KProfileVersionMandFlag = 32;

const TUint KVendorIDMandFlag = 64;

const TUint KProductIDMandFlag = 128;

// Expected mandatory fields value after the hid service record.

const TUint KHidServiceMandValue = KDevSubClassMandFlag

        | KCountryCodeMandFlag | KVirtuallyCabledMandFlag

        | KReconnectInitMandFlag | KDescriptorListMandFlag

        | KProfileVersionMandFlag;

// Expected mandatory fields value after the bt pnp service record.

const TUint KPnPServiceMandValue = KHidServiceMandValue | KVendorIDMandFlag

        | KProductIDMandFlag;

CHidSdpClient* CHidSdpClient::NewL(CBTHidDevice& aDevice,

        MHidSdpObserver& aObserver)

    {

    CHidSdpClient* self = NewLC(aDevice, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

CHidSdpClient* CHidSdpClient::NewLC(CBTHidDevice& aDevice,

        MHidSdpObserver& aObserver)

    {

    CHidSdpClient* self = new (ELeave) CHidSdpClient(aDevice, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CHidSdpClient::CHidSdpClient(CBTHidDevice& aDevice,

        MHidSdpObserver& aObserver) :

    CActive(EPriorityStandard), iDevice(aDevice), iObserver(aObserver),

            iParserState(EIdle)

    {

    }

CHidSdpClient::~CHidSdpClient()

    {

    delete iAgent;

    delete iHIDMatchList;

    delete iPNPMatchList;

    delete iSdpSearchPattern;

    }

void CHidSdpClient::ConstructL()

    {

    // Create the service search pattern object.

    iSdpSearchPattern = CSdpSearchPattern::NewL();

    // Create the attribute match list for HIDP Service.

    iHIDMatchList = CSdpAttrIdMatchList::NewL();

    TUint i;

    // Populate the list with the attributes we want to find.

    for (i = 0; i < gHIDServAttrCount; i++)

        {

        iHIDMatchList->AddL(TAttrRange(gHIDServiceAttributes[i].iID));

        }

    //Create the attribute match list for the BT PnP Service.

    iPNPMatchList = CSdpAttrIdMatchList::NewL();

    // Populate the list with the attributes we want to find.

    for (i = 0; i < gBTPnPAttrCount; i++)

        {

        iPNPMatchList->AddL(TAttrRange(gBTPnPServiceAttributes[i].iID));

        }

    }

void CHidSdpClient::Finish(TInt aError)

    {

    iParserState = EIdle;

    iObserver.HidSdpSearchComplete(aError);

    }

void CHidSdpClient::StartL()

    {

    // Delete any current agent.

    delete iAgent;

    iAgent = 0;

    // Reset the mandatory value bitmask.

    iMandAttrValue = 0;

    // Create a SDP Agent for the given BT Address.

    iAgent = CSdpAgent::NewL(*this, iDevice.iAddress);

    // Fill the record filter with the UUID of the HIDP Service.

    iSdpSearchPattern->AddL(KHidPServiceUUID);

    // Set the initial record filter.

    iAgent->SetRecordFilterL(*iSdpSearchPattern);

    // Request the next record.

    iAgent->NextRecordRequestL();

    // Set that we are inquiring for the HIDP Service.

    iParserState = EHIDService;

    }

void CHidSdpClient::Kill()

    {

    CActiveScheduler::Add(this);

    iStatus = KRequestPending;

    SetActive(); // Wait to be completed...

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone); // ...which we do ourself

    }

void CHidSdpClient::NextRecordRequestComplete(TInt aError,

        TSdpServRecordHandle aHandle, TInt /*aTotalRecordsCount*/)

    {

    TInt error = aError;

    if (aError == KErrNone)

        {

        switch (iParserState)

            {

            // If this is supposed to be the HIDP Service Record.

            case EHIDService:

                // Request the attributes from the HIDP Service.

            TRAP( error,

                    iAgent->AttributeRequestL(aHandle, *iHIDMatchList);

            )

                break;

                // If this is supposed to be the BT Pnp Service Record.

            case EBTPnPService:

                // Request the attributes from the BT Pnp Service.

            TRAP( error,

                    iAgent->AttributeRequestL(aHandle, *iPNPMatchList);

            )

                error = KErrNone; //PNP not found but we don't care! FOR RUNNING WITH IAR TESTER!

                break;

            default:

                User::Panic(KBTHIDServer, EBadState);

                break;

            }

        }

    // If we have had any error, inform the observer as we have finished.

    if (error != KErrNone)

        {

        Finish(error);

        }

    }

void CHidSdpClient::AttributeRequestResult(TSdpServRecordHandle /*aHandle*/,

        TSdpAttributeID aAttrID, CSdpAttrValue* aAttrValue)

    {

    switch (iParserState)

        {

        // If this is supposed to be a HIDP Service Attribute.

        case EHIDService:

            // Check its type and assign to the appropriate member in the 

            // device object.

            switch (aAttrValue->Type())

                {

                case ETypeUint:

                    switch (aAttrID)

                        {

                        case KHIDAttrDevRelNum:

                            iDevice.iDeviceReleaseNumber = aAttrValue->Uint();

                            break;

                        case KHIDAttrDevSubClass:

                            iDevice.iDeviceSubClass = aAttrValue->Uint();

                            // Record that this mandatory item was found

                            iMandAttrValue |= KDevSubClassMandFlag;

                            break;

                        case KHIDAttrCountryCode:

                            iDevice.iCountryCode = aAttrValue->Uint();

                            iMandAttrValue |= KCountryCodeMandFlag;

                            break;

                        case KHIDAttrProfileVersion:

                            iDevice.iProfileVersion = aAttrValue->Uint();

                            iMandAttrValue |= KProfileVersionMandFlag;

                            break;

                        default:

                            // This is an attribute we didn't request,

                            // or wrong type.

                            break;

                        }

                    break;

                case ETypeBoolean:

                    switch (aAttrID)

                        {

                        case KHIDAttrVirtuallyCabled:

                            iDevice.iVirtuallyCabled = aAttrValue->Bool();

                            iMandAttrValue |= KVirtuallyCabledMandFlag;

                            break;

                        case KHIDAttrReconnectInitiate:

                            iDevice.iReconnectInit = aAttrValue->Bool();

                            iMandAttrValue |= KReconnectInitMandFlag;

                            break;

                        case KHIDAttrNormallyConnectable:

                            iDevice.iNormallyConnectable = aAttrValue->Bool();

                            break;

                        default:

                            // This is an attribute we didn't request 

                            // or wrong type.

                            break;

                        }

                    break;

                case ETypeDES:

                    switch (aAttrID)

                        {

                        case KHIDAttrDescriptorList:

                            {

                                TRAP_IGNORE(

                                        CDescriptorListParser* visitor = new CDescriptorListParser(*(iDevice.iDescList));

                                        if( visitor )

                                            {

                                            CleanupStack::PushL(visitor);

                                            aAttrValue->AcceptVisitorL(*visitor);

                                            CleanupStack::PopAndDestroy(visitor);

                                            }

                                )

                            // Don't care about any error that could occur

                            iMandAttrValue |= KDescriptorListMandFlag;

                            }

                            break;

                        default:

                            // This is an attribute we didn't request 

                            // or wrong type.

                            break;

                        }

                    break;

                default:

                    // This is an attribute we didn't request or wrong type.

                    break;

                }

            break;

            // If this is supposed to be a BT Pnp Service Attribute.

        case EBTPnPService:

            // Check its type and assign to the appropriate member in the 

            // device object.

            switch (aAttrValue->Type())

                {

                case ETypeUint:

                    switch (aAttrID)

                        {

                        case KPnPAttrVendorID:

                            iDevice.iVendorID = aAttrValue->Uint();

                            iMandAttrValue |= KVendorIDMandFlag;

                            break;

                        case KPnPAttrProductID:

                            iDevice.iProductID = aAttrValue->Uint();

                            iMandAttrValue |= KProductIDMandFlag;

                            break;

                        default:

                            // This is an attribute we didn't request,

                            // or wrong type.

                            break;

                        }

                    break;

                default:

                    // This is an attribute we didn't request or wrong type.

                    break;

                }

            break;

        default:

            // We shouldn't get this state.

            User::Panic(KBTHIDServer, EBadState);

            break;

        }

    // Ownership has been transferred

    delete aAttrValue;

    }

void CHidSdpClient::AttributeRequestComplete(

        TSdpServRecordHandle /*aHandle*/, TInt aError)

    {

    if (aError == KErrNone)

        {

        switch (iParserState)

            {

            // If this is supposed to be the HIDP Service Record.

            case EHIDService:

                // If we found all the attributes we requested.

                if (iMandAttrValue == KHidServiceMandValue)

                    {

                    // Start a new sdp agent to request the BT Pnp 

                    // Service Record.

                    delete iAgent;

                    iAgent = 0;

                    TRAPD( res,

                            iAgent = CSdpAgent::NewL(*this, iDevice.iAddress);

                            iSdpSearchPattern->Reset();

                            iSdpSearchPattern->AddL(KPnPServiceUUID);

                            iAgent->SetRecordFilterL(*iSdpSearchPattern);

                            iAgent->NextRecordRequestL();

                            iParserState = EBTPnPService;

                    )

                    // If we failed, inform the observer of the error.

                    if (res != KErrNone)

                        {

                        Finish(res);

                        }

                    }

                else

                    {

                    // Not all attributes were found so inform the observer.

                    Finish(KErrNotFound);

                    }

                break;

                // If this is supposed to be the BT PnP Service Record.

            case EBTPnPService:

                // If we found all the attributes we requested.

                if (iMandAttrValue == KPnPServiceMandValue)

                    {

                    // Report success to the observer.

                    Finish(KErrNone);

                    }

                else

                    {

                    // Not all attributes were found so inform the observer.

                    Finish(KErrNone); //We don't care if all info wasn't found!

                    }

                break;

            default:

                // We shouldn't get this state.

                User::Panic(KBTHIDServer, EBadState);

                break;

            }

        }

    else

        {

        // Inform the observer of the error.

        Finish(aError);

        }

    }