btdiscoverer.cpp

Go to the documentation of this file.

/*
 * btdiscoverer.cpp,v 1.18 2004/01/10 14:27:10 mattid Exp
 *
 * COBAIN - Communications API for EPOC Environments
 * Copyright (C) 2002-2003 Matti Dahlbom, Matti Kokkola
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact: Matti Dahlbom <matti@777-team.org>
 *          Matti Kokkola <matti.kokkola@iki.fi>
 */

#include <es_sock.h>
#include <bt_sock.h>

#include "bluetoothcommunicator.h"
#include "btdiscoverer.h"
#include "cobainserver.h"
#include "serversession.h"
#include "Log.h"

CBTDiscoverer::CBTDiscoverer(RMessage &aMessage, CServerSession &aSession) 
    : CActive(CActive::EPriorityStandard), 
      iMessage(aMessage), 
      iSession(aSession),
      iCurrentDeviceIndex(-1)
{
}

CBTDiscoverer::~CBTDiscoverer()
{
    iDeviceAddresses.ResetAndDestroy();
    delete iSdpPattern;
    delete iAgent;
    delete iAttrMatchList;
}

CBTDiscoverer * CBTDiscoverer::NewL(RMessage &aMessage, CServerSession &aSession)
{
    CBTDiscoverer *d = new (ELeave) CBTDiscoverer(aMessage, aSession);
    CleanupStack::PushL(d);
    d->ConstructL();
    CleanupStack::Pop(); // d

    return d;
}

void CBTDiscoverer::ConstructL()
{
    // create SDP search pattern
    delete iSdpPattern;
    iSdpPattern = NULL;
    iSdpPattern = CSdpSearchPattern::NewL();

    // create attribute match list for looking up service descriptor + name
    iAttrMatchList = CSdpAttrIdMatchList::NewL();
    iAttrMatchList->AddL(TAttrRange(KSdpAttrIdProtocolDescriptorList));
    TSdpAttributeID attr_id = KSdpAttrIdOffsetServiceName + 
                              KSdpAttrIdBasePrimaryLanguage;
    iAttrMatchList->AddL(TAttrRange(attr_id));

    // extract service id (UUID) of the service being discovered. if 0, all services
    // get discovered
    TUint service_id = iMessage.Int2();
    if( service_id != 0 ) {
        // do a lookup by UUID
        iSdpPattern->AddL(service_id);
        Log::Print(_L("CBTDiscoverer::ConstructL() id: 0x%X"), service_id);
    } else {
        // lookup everything supporting RFCOMM/L2CAP
        iSdpPattern->AddL(KL2CAP);
        iSdpPattern->AddL(KRFCOMM);
        Log::Print(_L("CBTDiscoverer::ConstructL() looking up all"));
    }
}

void CBTDiscoverer::DoCancel()
{
    // must close host resolver
    iHr.Close();

    delete iPeerList;
    iPeerList = NULL;
}

void CBTDiscoverer::StartL(RSocketServ &aSocketServ)
{
    Log::Print(_L("CBTDiscoverer::StartL()"));

    // allocate new peer list
    delete iPeerList;
    iPeerList = NULL;
    iPeerList = new (ELeave) TPeerDataList();

    TProtocolDesc pInfo;
    User::LeaveIfError(aSocketServ.FindProtocol(_L("BTLinkManager"), pInfo));

    // create and initialise an RHostResolver
    User::LeaveIfError(iHr.Open(aSocketServ, pInfo.iAddrFamily, pInfo.iProtocol));

    // set up a discovery query 
    TInquirySockAddr addr;
    TNameEntry name;
    addr.SetIAC(KGIAC);
    addr.SetAction(KHostResName | KHostResInquiry);

    // add to active scheduler
    CActiveScheduler::Add(this);

    // initiate discovery of the first device
    TRequestStatus status;
    iHr.GetByAddress(addr, iNameEntry, iStatus);

    // wait for completion
    SetActive();
}

void CBTDiscoverer::DiscoverServices(TNameRecord &aNameRecord)
{
    delete iAgent;
    iAgent = NULL;

    Log::Print(_L("DiscoverServices(): %S"), &(aNameRecord.iName));

    // extract bluetooth address
    TBTDevAddr btaddr = static_cast<TBTSockAddr>(aNameRecord.iAddr).BTAddr();

    TRAPD(err, (iAgent = CSdpAgent::NewL(*this, btaddr)));
    if( err != KErrNone ) {
        User::Panic(KBTDiscovererPanic, KErrBtdiscovererAllocFailed);
    }   

    iAgent->SetRecordFilterL(*iSdpPattern);
    iAgent->NextRecordRequestL(); // will result in NextRecordRequestComplete()
}

// initializes client's peer list and completes client call 
void CBTDiscoverer::FinishDiscovery()
{
    Log::Print(_L("FinishDiscovery()"));

    iCurrentDeviceIndex = -1;

    // give up peer list
    iSession.SetPeerList(iPeerList);
    iPeerList = NULL;

    // write number of peers and complete the original call
    TBuf8<sizeof(TInt)> buf;
    buf.Copy((const TUint8 *)(&iNumPeers), sizeof(TInt));
    iMessage.WriteL(iMessage.Ptr1(), buf);

    iMessage.Complete(KErrNone);

    // release memory
    iDeviceAddresses.ResetAndDestroy();
}

void CBTDiscoverer::DeviceDiscovered()
{
    if( iStatus == KErrNone ) {
        TNameRecord record = iNameEntry();

  //      //Log::Print(_L("found device %S"), &(record.iName));

        // create new instance
        TNameRecord *new_record = NULL;
        TRAPD(err, (new_record = new (ELeave) TNameRecord()));
        if( err != KErrNone ) {
            User::Panic(KBTDiscovererPanic, KErrBtdiscovererAllocFailed);
        } 

        // initialize the new instance
        Mem::Copy(new_record, &record, sizeof(TNameRecord));

        // add the instance to device address list 
        iDeviceAddresses.Append(new_record);

        // discover next device
        iHr.Next(iNameEntry, iStatus);
        SetActive();
    } else {
        Log::Print(_L("** no more devices"));

        // no more devices; all done
        iHr.Close();

        // start discovering services
        if( iDeviceAddresses.Count() > 0 ) {
            // create service discover agent
            iCurrentDeviceIndex = 0;
            DiscoverServices(*iDeviceAddresses[iCurrentDeviceIndex]);
        } else {
            // no devices found! list is empty; allow client call return
            FinishDiscovery(); 
        }
    }
}

void CBTDiscoverer::RunL()
{
  //  //Log::Print(_L("CBTDiscoverer::RunL()"));

    DeviceDiscovered();
}

TInt CBTDiscoverer::RunError(TInt aError)
{
    //Log::Print(_L("RunError(): %d"), aError);

    return aError;
}

// from MSdpAgentNotifier

void CBTDiscoverer::AttributeRequestComplete(TSdpServRecordHandle /*aHandle*/, 
                                             TInt aError)
{
    //Log::Print(_L("AttributeRequestComplete()"));

    if( aError != KErrNone ) {
        //Log::Print(_L("AttributeRequestComplete(): %d"), aError);
        //##TODO## handle
    } else {
        // attributes for this service done - create a peer record
        TNameRecord *record = iDeviceAddresses[iCurrentDeviceIndex];
        TBTDevAddr btaddr = static_cast<TBTSockAddr>(record->iAddr).BTAddr();
        TPeerData *data = new (ELeave) TPeerData();
        data->iDeviceName = record->iName;
        data->iDeviceAddress = btaddr.Des();
        data->iServiceName = iServiceName;
        data->p.iBtProperties.iRfcommPort = iRfcommPort;
        data->p.iBtProperties.iL2capPort = iL2capPort;
        iPeerList->Append(data);
        iNumPeers++;

        Log::Print(_L("added peer: L: %d, R: %d"), iL2capPort, iRfcommPort);    

        // request next service record.
        // will result in call to NextRecordRequestComplete()
        TRAPD(err, iAgent->NextRecordRequestL());
        if( err != KErrNone ) {
            //Log::Print(_L("iAgent->NextRecordRequestL() error: %d"), err);
            //##TODO## handle
        }
    }
}

void CBTDiscoverer::AttributeRequestResult(TSdpServRecordHandle /*aHandle*/, 
                                           TSdpAttributeID /*aAttrID*/, 
                                           CSdpAttrValue* aAttrValue)
{
    //Log::Print(_L("AttributeRequestResult()"));

    // parse through the attributes - will result in calls to 
    // VisitAttributeValueL()
    TRAPD(err, aAttrValue->AcceptVisitorL(*this));
}

// called when discovery of a advertised service completes
void CBTDiscoverer::NextRecordRequestComplete(TInt aError, 
                                              TSdpServRecordHandle aHandle, 
                                              TInt aTotalRecordsCount)
{
    TInt err;
    Log::Print(_L("NRRC(): error: %d, count: %d, handle: %d"), 
                  aError, aTotalRecordsCount, aHandle);

    if( (aError == KErrNone) && (aTotalRecordsCount > 0) ) {
        // services records left - reset service information for new service
        iRfcommPort = -1;
        iL2capPort = -1;
        iServiceName.Zero();
        iLastUuid32 = 0;

        // request protocol descriptor to get the service details including
        // the port the service is listening to and the service name. will result in 
        // call to AttributeRequestResult()
        TRAP(err, iAgent->AttributeRequestL(aHandle, *iAttrMatchList));
    } else {
        // no more services for this device - discover services of next device
        iCurrentDeviceIndex++;

        if( iCurrentDeviceIndex < iDeviceAddresses.Count() ) {
            DiscoverServices(*iDeviceAddresses[iCurrentDeviceIndex]);
        } else {
            // all devices processed - all done!
            FinishDiscovery();
        }
    }
}

// from MSdpAttributeValueVisitor

void CBTDiscoverer::VisitAttributeValueL(CSdpAttrValue &aValue, 
                                         TSdpElementType aType)
{
    TBuf<64> bufw;
    TInt index;

    if( aType != ETypeUint ) {
        // reset last 32bit uuid marker
        iLastUuid32 = 0;
    }
    
    switch( aType ) {
        case ETypeUUID:
            ParseUuid(bufw, aValue.UUID(), iLastUuid32);
            Log::Print(_L("UUID: %S"), &bufw);
            // add to a UUID list! (##TODO##)
            break;
        case ETypeUint:
            Log::Print(_L("Uint: %u"), aValue.Uint());
            if( iLastUuid32 == KRFCOMM ) {
                iRfcommPort = aValue.Uint();
            } else if( iLastUuid32 == KL2CAP ) {
                iL2capPort = aValue.Uint();
            }
            break;
        case ETypeDES:
            //Log::Print(_L("DES"));
            break;
        case ETypeNil:
            Log::Print(_L("Nil"));
            break;
        case ETypeInt:
            Log::Print(_L("Int: %d"), aValue.Int());
            break;
        case ETypeString:
            // the string is the service name
            iServiceName.Copy(aValue.Des());
            bufw.Copy(aValue.Des());

            // trim trailing zero(s)
            index = iServiceName.Locate(0x00);
            if( index != KErrNotFound ) {
                iServiceName.SetLength(index);
            }
            
            // print last char value
            //Log::Print(_L("last char: %d"), (TInt)bufw[bufw.Length() - 1]);
            Log::Print(_L("String: %S"), &bufw);
            break;
        case ETypeBoolean:
            Log::Print(_L("Boolean"));
            break;
        case ETypeDEA:
            Log::Print(_L("DEA"));
            break;
        case ETypeURL:
            Log::Print(_L("URL"));
            break;
        case ETypeEncoded:
            Log::Print(_L("Encoded"));
            break;
        default:
            // dont really care..
            break;
    }
}

void CBTDiscoverer::StartListL(CSdpAttrValueList& /*aList*/)
{
    // no implementation
}

void CBTDiscoverer::EndListL()
{
    // no implementation
}

// util method for parsing an UUID into a hexstring
void CBTDiscoverer::ParseUuid(TDes &aBuf, const TUUID &aUuid, TUint32 &aUuid32)
{
    TPtrC8 uuid(aUuid.ShortestForm());
    TInt len = uuid.Length();

//    Log::Print(_L("ParseUuid(): UUID len: %d"), len);

    switch( len ) {
        case 2:
            aUuid32 = (TUint)BigEndian::Get16(uuid.Ptr());
            aBuf.Format(_L("0x%X"), aUuid32);
            break;
        case 4:
            aUuid32 = BigEndian::Get32(uuid.Ptr());
            aBuf.Format(_L("0x%X"), aUuid32);
            break;
        case 16:
            aUuid32 = 0;
            //##TODO##
            break;
    }
}

---