/*

 * Copyright (c) 2009 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:  Implementation indevice handler

 *

 */

#include "indevicehandler.h"

#include <qcpixsearcher.h>

#include <qcpixdocument.h>

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

// InDeviceHandler::InDeviceHandler()

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

//

InDeviceHandler::InDeviceHandler() :

    mSearchInterface(0), mSearchResultCount(0)

    {

    }

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

// InDeviceHandler::~InDeviceHandler()

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

//

InDeviceHandler::~InDeviceHandler()

    {

    if (mSearchInterface)

        {

        delete mSearchInterface;

        }

    }

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

// InDeviceHandler::getSearchResult(int aError, int estimatedResultCount)

// aError: error code

// estimatedResultCount: number of hits

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

//

void InDeviceHandler::getSearchResult(int aError, int estimatedResultCount)

    {

    qDebug() << aError << estimatedResultCount;

    mSearchResultCount = estimatedResultCount;

    emit handleAsyncSearchResult(aError, estimatedResultCount);

    }

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

// InDeviceHandler::getDocumentAsync(int aError, QCPixDocument* aDocument)

// aError: error code

// aDocument: holding the result item

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

//

void InDeviceHandler::getDocumentAsync(int aError, QCPixDocument* aDocument)

    {

    emit handleDocument(aError, aDocument);

    }

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

// InDeviceHandler::getDocumentAtIndex(int aIndex)

// aIndex: item index to be found

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

//

QCPixDocument* InDeviceHandler::getDocumentAtIndex(int aIndex)

    {

    QCPixDocument* doc = NULL;

    if (mSearchInterface)

        {

        try

            {

            doc = mSearchInterface->getDocument(aIndex);

            }

        catch (...)

            {

            delete doc;

            return NULL;

            }

        }

    return doc;

    }

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

// InDeviceHandler::getSearchResultCount()

// gets the number of hits

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

//

int InDeviceHandler::getSearchResultCount()

    {

    return mSearchResultCount;

    }

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

// InDeviceHandler::getDocumentAsyncAtIndex(int aIndex)

// aIndex :  index of item to be found async

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

//

void InDeviceHandler::getDocumentAsyncAtIndex(int aIndex)

    {

    if (mSearchInterface)

        {

        try

            {

            mSearchInterface->getDocumentAsync(aIndex);

            }

        catch (...)

            {

            // handle the exception

            return;

            }

        }

    }

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

// InDeviceHandler::searchAsync

// aSearchAsyncString: string to be searched

// async

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

//

void InDeviceHandler::searchAsync(QString aSearchAsyncString, QString/* aDefaultSearchField*/)

    {

    if (aSearchAsyncString.length())

        {

        mSearchResultCount = 0;

        if (mSearchInterface)

            {

            try

                {

                mSearchInterface->searchAsync(aSearchAsyncString);

                }

            catch (...)

                {

                // handle the exception

                return;

                }

            }

        }

    }

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

// InDeviceHandler::cancelLastSearch()

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

//

void InDeviceHandler::cancelLastSearch()

    {

    if (mSearchInterface)

        {

        try

            {

            mSearchInterface->cancelSearch();

            }

        catch (...)

            {

            // handle the exception

            return;

            }

        }

    }

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

// InDeviceHandler::setCategory

// astring: setting categories to be searched

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

//

void InDeviceHandler::setCategory(QString astring)

    {

    if (mSearchInterface)

        {

        delete mSearchInterface;

        mSearchInterface = NULL;

        }

    if (astring.length())

        {

        QString database("root ");

        database.append(astring);

        mSearchInterface = QCPixSearcher::newInstance(database,

                DEFAULT_SEARCH_FIELD);

        }

    else

        {

        mSearchInterface = QCPixSearcher::newInstance("root",

        DEFAULT_SEARCH_FIELD);

        }

    if (mSearchInterface)

        {

        try

            {

            mSearchInterface->connect(mSearchInterface,

                    SIGNAL(handleSearchResults(int,int)), this,

                    SLOT(getSearchResult(int,int)));

            }

        catch (...)

            {

            // handle the exception

            }

        try

            {

            mSearchInterface->connect(mSearchInterface,

                    SIGNAL(handleDocument(int,QCPixDocument*)), this,

                    SLOT(getDocumentAsync(int,QCPixDocument*)));

            }

        catch (...)

            {

            // handle the exception

            }

        }

    }

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

// InDeviceHandler::isPrepared()

// verify the mSearchInterface is prepared or not

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

//

bool InDeviceHandler::isPrepared()

    {

    if (mSearchInterface)

        {

        return true;

        }

    return false;

    }