/*

* 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:

*

*/

#include "discoveryagent.h"

#include "bluetoothdevicediscoverer.h"

#include "fs_methodcall.h"

#include "javajniutils.h"

#include "exceptionbase.h"

using namespace java::util;

namespace java

{

namespace bluetooth

{

DiscoveryAgent::DiscoveryAgent(BluetoothFunctionServer* aServer)

{

    JELOG2(EJavaBluetooth);

    // Initializing discovery agent data

    mFunctionServer = aServer;

    mSocketServerStatus = SOCKETSERVER_DISCONNECTED;

    // Initializing device discovery data

    mDeviceDiscoverer = NULL;

}

DiscoveryAgent::~DiscoveryAgent()

{

    JELOG2(EJavaBluetooth);

    cleanupDeviceDiscoverer();

}

/**

 * Starts the device inquiry. After starts the inquiry, call made to the java

 * indicates that inquiry started.

 *

 * @param aJni

 * @param aPeer

 * @param aAccessCode Inquiry code

 * @param aMonitor    Monitor which waits for this operation to complete

 */

int DiscoveryAgent::startDeviceDiscovery(JNIEnv* aJni, jobject& aPeer,

        int aAccessCode)

{

    JELOG2(EJavaBluetooth);

    jclass peerClass = (*aJni).GetObjectClass(aPeer);

    //Get Method ID of Device Discovered Callback

    mDeviceDiscoveredMethod = aJni->GetMethodID(peerClass,

                              "deviceDiscoveredCallBack",

                              "(Ljava/lang/String;Ljava/lang/String;I)V");

    //We call Device Inquiry Started Callback in BluetoothStackS60 itself

    mDeviceDiscoveryStartedMethod = aJni->GetMethodID(peerClass,

                                    "deviceInquiryStartedCallback", "()V");

    //Check if all the JNI inits have succeeded

    if (NULL == mDeviceDiscoveredMethod || NULL

            == mDeviceDiscoveryStartedMethod)

    {

        //Error in initialization

        ELOG(EJavaBluetooth,

             "- DiscoveryAgent::startDeviceDiscovery Error in JNIInit");

        return -1;

    }

    TRAPD(err, CallMethodL(this,

                           &java::bluetooth::DiscoveryAgent::discoverDevicesFsL, aAccessCode,

                           mFunctionServer));

    if (KErrNone != err)

    {

        cleanupDeviceDiscoverer();

        ELOG1(EJavaBluetooth,

              "- DiscoveryAgent::startDeviceDiscovery Error %d", err);

        return err;

    }

    LOG(EJavaBluetooth, EInfo,

        " DiscoveryAgent::startDeviceDiscovery Started Callback");

    startedDeviceDiscovery(aJni, aPeer);

    return err;

}

void DiscoveryAgent::discoverDevicesFsL(int aAccessCode)

{

    mDeviceDiscoverer = BluetoothDeviceDiscoverer::NewL(mFunctionServer);

    CleanupStack::PushL(mDeviceDiscoverer);

    mDeviceDiscoverer->DiscoverDevicesL(aAccessCode);

    CleanupStack::Pop(mDeviceDiscoverer);

}

/**

 * Cancels the device inquiry

 */

bool DiscoveryAgent::cancelDeviceDiscovery()

{

    JELOG2(EJavaBluetooth);

    if (mDeviceDiscoverer)

    {

        mDeviceDiscoverer->cancel();

    }

    return true;

}

/**

 * Makes callback to Java indicates that the inquiry started.

 */

void DiscoveryAgent::startedDeviceDiscovery(JNIEnv* aJni, jobject& aPeer)

{

    JELOG2(EJavaBluetooth);

    //Call method in Java here to notify that device discovery has been started

    //This too happens in Function Server Context.

    (*aJni).CallVoidMethod(aPeer, mDeviceDiscoveryStartedMethod);

}

/**

 * Searching for the next device.

 * Returns immediately, if already any device discovered;

 * otherwise waits for the new device.

 */

int DiscoveryAgent::getNextDevice(DiscoveredDevice &aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    int status = mDeviceDiscoverer->getNextDevice(aDiscoveredDevice);

    if (STATUS_DEVICE_FOUND != status)

    {

        cleanupDeviceDiscoverer();

    }

    return status;

}

/**

 * Makes callback to the Java only when new device found.

 * Returns the inquiry status.

 */

int DiscoveryAgent::doDeviceDiscoveryCallback(JNIEnv* aJni, jobject& aPeer,

        DiscoveredDevice &aDiscoveredDevice)

{

    JELOG2(EJavaBluetooth);

    jstring devAddr = NULL;

    jstring devName = NULL;

    int deviceClass = 0;

    if (STATUS_DEVICE_FOUND == aDiscoveredDevice.mInquiryStatus)

    {

        LOG(EJavaBluetooth, EInfo,

            "  DiscoveryAgent::doDeviceDiscoveryCallback: Device discovered callback");

        if (NULL != aDiscoveredDevice.mDeviceAddr)

        {

            try

            {

                devAddr = java::util::JniUtils::wstringToJstring(aJni,

                          *(aDiscoveredDevice.mDeviceAddr));

            }

            catch (ExceptionBase ex)

            {

                // Nothing to handle

            }

        }

        else

        {

            ELOG(EJavaBluetooth,

                 "  DiscoveryAgent Really Serious Error: Address is NULL !!");

        }

        if (NULL != aDiscoveredDevice.mDeviceName)

        {

            try

            {

                devName = java::util::JniUtils::wstringToJstring(aJni,

                          *(aDiscoveredDevice.mDeviceName));

            }

            catch (ExceptionBase ex)

            {

                // Nothing to handle

            }

        }

        else

        {

            ELOG(EJavaBluetooth,

                 "  DiscoveryAgent::doDeviceDiscoveryCallback: Device Name is NULL");

        }

        deviceClass = aDiscoveredDevice.mDeviceClass;

        (*aJni).CallVoidMethod(aPeer, mDeviceDiscoveredMethod, devAddr,

                               devName, deviceClass);

    }

    LOG1(EJavaBluetooth, EInfo,

         "- DiscoveryAgent::doDeviceDiscoveryCallback: %d",

         aDiscoveredDevice.mInquiryStatus);

    return aDiscoveredDevice.mInquiryStatus;

}

/**

 * Deletes the BluetoothDeviceDiscoverer

 */

void DiscoveryAgent::cleanupDeviceDiscoverer()

{

    JELOG2(EJavaBluetooth);

    delete mDeviceDiscoverer;

    mDeviceDiscoverer = NULL;

}

/**

 * Starts lookup for the friendly name of the device

 * On success, returns the friendly name of the device

 * Otherwise NULL

 *

 * Note: Must free resultant friendly name, whenever not required.

 */

std::wstring* DiscoveryAgent::lookupFriendlyNameL(long long aDevAddr)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo,

         "+ DiscoveryAgent::lookupFriendlyName DeviceAddress:%x", aDevAddr);

    TInt64 devAddr = (TInt64) aDevAddr;

    std::wstring* result = NULL;

    CallMethodL(result, this, &java::bluetooth::DiscoveryAgent::nameLookupL,

                devAddr, mFunctionServer);

    return result;

}

/**

 * Creates the BluetoothNameLookup object

 */

std::wstring* DiscoveryAgent::nameLookupL(TInt64 aDevAddr)

{

    JELOG2(EJavaBluetooth);

    std::wstring* result = NULL;

    BluetoothNameLookup * nameLookup = BluetoothNameLookup::NewL();

    CleanupStack::PushL(nameLookup);

    result = nameLookup->doDeviceNameLookupL(aDevAddr);

    CleanupStack::Pop(nameLookup);

    delete nameLookup;

    return result;

}

/*

 *   ------- Service Search Methods --------

 */

int DiscoveryAgent::StartSearchServices(JNIEnv* aJni, jobject& aPeer,

                                        TInt64 aRemoteAddress, TPtrC8 aUuidsDes, TPtrC16 aAttrIdsDes,

                                        java::util::Monitor* aMonitor)

{

    JELOG2(EJavaBluetooth);

    mServiceSearchMonitor = aMonitor;

    mServiceSearchStatus = -1;

    jclass peerClass = (*aJni).GetObjectClass(aPeer);

    //Get Method ID of Service Search Started Callback

    mServiceSearchStartedMethod = aJni->GetMethodID(peerClass,

                                  "serviceSearchStartedCallback", "()V");

    //Check if all the JNI inits have succeeded

    if (NULL == mServiceSearchStartedMethod)

    {

        //Error in initialization

        ELOG(EJavaBluetooth,

             "- DiscoveryAgent::StartSearchServices: Error in JNIInit ");

        return -1;

    }

    LOG(EJavaBluetooth, EInfo,

        "  DiscoveryAgent::StartSearchServices: Starting service search ");

    TRAPD(err, CallMethodL(this,

                           &java::bluetooth::DiscoveryAgent::searchServiceFsL, aRemoteAddress,

                           aUuidsDes, aAttrIdsDes, mFunctionServer));

    if (KErrNone == err)

    {

        StartedServiceSearch(aJni, aPeer);

    }

    return err;

}

void DiscoveryAgent::searchServiceFsL(TInt64 aRemoteAddress, TPtrC8 aUuidsDes,

                                      TPtrC16 aAttrIdsDes)

{

    mServiceSearcher = BluetoothServiceSearcher::New(this, mFunctionServer);

    TRAPD(err, mServiceSearcher->SearchServicesL(aRemoteAddress, aUuidsDes,

            aAttrIdsDes));

    if (KErrNone != err)

    {

        ELOG(EJavaBluetooth,

             "  DiscoveryAgent::SearchServiceFsL: Error occured!! ");

        CleanupServiceSearcher();

        User::LeaveIfError(err);

    }

}

void DiscoveryAgent::StartedServiceSearch(JNIEnv* aJni, jobject& aPeer)

{

    JELOG2(EJavaBluetooth);

    mIsServiceSearchOn = true;

    (*aJni).CallVoidMethod(aPeer, mServiceSearchStartedMethod);

}

void DiscoveryAgent::ServiceSearchCompleted(int aStatus)

{

    JELOG2(EJavaBluetooth);

    mIsServiceSearchOn = false;

    mServiceSearchStatus = aStatus;

    mServiceSearchMonitor->notify();

    CleanupServiceSearcher();

}

bool DiscoveryAgent::CancelServiceSearch()

{

    JELOG2(EJavaBluetooth);

    if (NULL != mServiceSearcher)

    {

        CallMethod(

            this,

            &java::bluetooth::DiscoveryAgent::cancelAndCleanupServiceSearchFs,

            mFunctionServer);

    }

    CleanupAllServiceSearcherInfo();

    mIsServiceSearchOn = false;

    return true;

}

void DiscoveryAgent::cancelAndCleanupServiceSearchFs()

{

    mServiceSearcher->cancelServiceSearch();

    CleanupServiceSearcher();

}

int DiscoveryAgent::getStatusOfCompletion()

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo, "+ DiscoveryAgent::getStatusOfCompletion: %d",

         mServiceSearchStatus);

    return mServiceSearchStatus;

}

int DiscoveryAgent::PopulateServiceRecordAttrValue(JNIEnv* aJni,

        jobject& aPeer, TInt64 aRemoteAddress, long aHandle,

        TPtrC16 aAttrIdsDes, jobject aServiceRecordImpl,

        java::util::Monitor* aMonitor)

{

    JELOG2(EJavaBluetooth);

    mServiceSearchMonitor = aMonitor;

    jclass peerClass = (*aJni).GetObjectClass(aPeer);

    LOG(EJavaBluetooth, EInfo,

        "  DiscoveryAgent::PopulateServiceRecord: Starting populating service records ");

    TRAPD(err, CallMethodL(this,

                           &java::bluetooth::DiscoveryAgent::populateServiceRecordAttrValueFs,

                           aRemoteAddress, aHandle, aAttrIdsDes, aServiceRecordImpl,

                           mFunctionServer));

    return err;

}

void DiscoveryAgent::populateServiceRecordAttrValueFs(TInt64 aRemoteAddress,

        long aHandle, TPtrC16 aAttrIdsDes, jobject aServiceRecordImpl)

{

    mServiceSearcher = BluetoothServiceSearcher::New(this, mFunctionServer);

    mServiceSearcher->PopulateServiceRecordsL(aRemoteAddress, aHandle,

            aAttrIdsDes, aServiceRecordImpl);

}

void DiscoveryAgent::PopulateRecordCompleted(int aStatus)

{

    JELOG2(EJavaBluetooth);

    mPopulateRecordStatus = aStatus;

    mServiceSearchMonitor->notify();

    CleanupServiceSearcher();

}

int DiscoveryAgent::GetPopulateServiceRecordStatus()

{

    JELOG2(EJavaBluetooth);

    return mPopulateRecordStatus;

}

bool DiscoveryAgent::CancelPopulateServiceRecordAttrValue()

{

    JELOG2(EJavaBluetooth);

    mIsServiceSearchOn = false;

    TRAP_IGNORE(CallMethodL(mServiceSearcher,

                            &java::bluetooth::BluetoothServiceSearcher::cancelServiceSearch,

                            mFunctionServer));

    return true;

}

void DiscoveryAgent::CleanupServiceSearcher()

{

    JELOG2(EJavaBluetooth);

    //Delete all contained objects

    if (mServiceSearcher)

    {

        delete mServiceSearcher;

        mServiceSearcher = NULL;

    }

}

void DiscoveryAgent::CleanupAllServiceSearcherInfo()

{

    JELOG2(EJavaBluetooth);

    // Clear all realted data

    mServiceSearchStartedMethod = NULL;

    mIsServiceSearchOn = false;

    mPopulateRecordStatus = KErrNone;

    mServiceSearchMonitor = NULL;

}

} //end namespace bluetooth

} //end namespace java