/*
* 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: 
*     Maptile service implementation
*
*/


#include <centralrepository.h> 
#include <locationservicedefines.h>
#include <qvaluespacepublisher.h>
#include <qvaluespacesubscriber.h>
#include <qfile.h>
#include "cntmaptileservice.h"
#include "cntmaptiledblookuptable.h"

// CONSTANTS
// Maptile interface uid
const TUid KUidMapTileInterface = { 0x2002C3A8 };
// Central Repository Key IDs
const TInt KEnableLocationFeature           = 0x1;

const char *CNT_MAPTILE_STATUS_RECEIVER = "/maptilestatuspublisher/name";
const char *CNT_MAPTILE_STATUS_PUBLISHER = "/cntmaptilepublisher";

const char*  CNT_PORTRAIT_MAPTILE_IMAGE = "_Vertical";
const char*  CNT_LANDSCAPE_MAPTILE_IMAGE = "_Contact_Horizontal";

// -----------------------------------------------------------------------------
// CntMapTileService::CntMapTileService()
// Default constructor
// -----------------------------------------------------------------------------
//
CntMapTileService::CntMapTileService()
{
    //publisher
    mPublisher = NULL;
    
    //subscriber
    mSubscriber = new QValueSpaceSubscriber( CNT_MAPTILE_STATUS_RECEIVER );
    //Connect for maptile status change key
    QObject::connect(mSubscriber, SIGNAL(contentsChanged()), this, SLOT(setMaptileStatus()));

}


// -----------------------------------------------------------------------------
// CntMapTileService::~CntMapTileService()
// Destructor
// -----------------------------------------------------------------------------
//
CntMapTileService::~CntMapTileService()
{
    if( mSubscriber )
    {
        delete mSubscriber;
        mSubscriber = NULL;
    }
    
    if( mPublisher )
    {
        delete mPublisher;
        mPublisher = NULL;
    }
}
// -----------------------------------------------------------------------------
// CntMapTileService::isLocationFeatureEnabled()
// Checks whether location feature is enabled or disabled
// -----------------------------------------------------------------------------
//
bool CntMapTileService::isLocationFeatureEnabled()
{ 
    //Create the centrep with uid 0x2002C3A8
    bool enableLocationFeature = false;
    
    CRepository* centralRepository = NULL;  

    TRAPD( err, centralRepository = CRepository::NewL( KUidMapTileInterface ) );

    if ( KErrNone == err )
    {
        TInt repValue;
      
        //Get the Location feature flag 
        TInt ret = centralRepository->Get( KEnableLocationFeature , repValue );
      
        if ( ret == KErrNone && repValue == 1 )
        {
            enableLocationFeature  = true;
        }
           
         delete centralRepository;
    }
           
    return   enableLocationFeature;
    
}


// -----------------------------------------------------------------------------
// CntMapTileService::getMapTileImage()
// Gets the maptile image path associated with a contact.
// -----------------------------------------------------------------------------
//
int CntMapTileService::getMapTileImage( 
                                 int contactId , 
                                 ContactAddressType sourceType, 
                                 QString& imagePath,
                                 Qt::Orientations orientation )    
{
    
    TLookupItem lookupItem;
    
    int addressCount = 0;
    int maptileStatus = MapTileFetchingUnknownError;
    
    //Read the entry from maptile database
    int error = readEntryFromMaptileDataBase( contactId, sourceType, lookupItem, addressCount );
    
    //if entry available returns the file path otherwise NULL. 
    if ( KErrNone == error  )
    {
        maptileStatus = lookupItem.iFetchingStatus;
        
        if( maptileStatus == MapTileFetchingCompleted )
        {
            //Get the image path
            QString imageFile((QChar*)lookupItem.iFilePath.Ptr(),
                    lookupItem.iFilePath.Length());
            if( orientation == Qt::Vertical )
            {
                imageFile.append( CNT_PORTRAIT_MAPTILE_IMAGE );
            }
            else
            { 
                imageFile.append( CNT_LANDSCAPE_MAPTILE_IMAGE );
            }
            imagePath = imageFile;
            
            //Check if File exists
            if ( !QFile::exists( imagePath ) )
            {
                imagePath.clear();
                maptileStatus = MapTileFetchingUnknownError;
            }
        }
        else if( maptileStatus == MapTileFetchingNetworkError ||
                    maptileStatus == MapTileFetchingInProgress )
        {
            //Publish the contact id for maptile processing
           	publishValue( contactId, sourceType, addressCount );
        }

    }
    else if ( KErrNotFound == error )
    {
        //If entry is not found , it will be a newly added entry.
        publishValue( contactId, sourceType, addressCount );
        maptileStatus = MapTileFetchingInProgress;
    }
   
    //Return the maptile status
    return maptileStatus;
}


// -----------------------------------------------------------------------------
// CntMapTileService::setMaptileStatus()
// Emits the maptile status changed event to contact application
// -----------------------------------------------------------------------------
//
void CntMapTileService::setMaptileStatus()
{
    QString imagePath;
    ContactAddressType addressType = AddressPreference;
    
    QStringList subPath = mSubscriber->subPaths();
    QVariant value = mSubscriber->value(subPath.at(0));
    
    //Subscriber Protocol : [contactid-addresstype-maptilestatus]
    QStringList text = value.toString().split("-");
    int id = text.at(0).toInt();
    int status = text.at(2).toInt();
    
    switch( text.at(1).toInt() )
    {
        case ESourceContactsPref:
            addressType = AddressPreference;
            break;
        case ESourceContactsWork:
            addressType = AddressWork;
            break;        
        case ESourceContactsHome:
            addressType = AddressHome;
            break;
        default:
            break;
    }
  
    //Emit the maptile status signal 
    int type = addressType;
    if( mLastViewedContactId == id )
    {
        emit maptileFetchingStatusUpdate( mLastViewedContactId, type , status );
    }
}


// -----------------------------------------------------------------------------
// CntMapTileService::publishValue()
// Publish the the contact id and address for which maptile to be processed.
// -----------------------------------------------------------------------------
//
void CntMapTileService::publishValue( int id, ContactAddressType sourceType, int addressCount )
{
    
    mLastViewedContactId = id;
    int addressType = ESourceInvalid;
    
    switch( sourceType )
    {
        case AddressPreference:
            addressType = ESourceContactsPref;
            break;
        case AddressWork:
            addressType = ESourceContactsWork;
            break;
        case AddressHome:
            addressType = ESourceContactsHome;
            break;
    }
    
    if ( !mPublisher )
    {
        /* Constructs a QValueSpacePublisher that publishes values under path /mypublisher*/
        mPublisher = new QValueSpacePublisher( CNT_MAPTILE_STATUS_PUBLISHER, this);
    }
       
    /* Publisher protocol [appid-addresstype-count] */
    mContactEntryInfo.clear();
    mContactEntryInfo.append( QVariant(id).toString());
    mContactEntryInfo.append( QChar('-') );
    mContactEntryInfo.append( QVariant(addressType).toString());
    mContactEntryInfo.append( QChar('-') );
    mContactEntryInfo.append( QVariant(addressCount).toString() );
    
    mPublisher->setValue("name", mContactEntryInfo.toAscii() );
    mPublisher->sync();
    
}

// -----------------------------------------------------------------------------
// CntMapTileService::readEntryFromMaptileDataBase()
// Read the entry from maptile database
// -----------------------------------------------------------------------------
//
int CntMapTileService::readEntryFromMaptileDataBase( 
            int id, ContactAddressType sourceType, TLookupItem& aLookupItem, int& aNoOfAddress )
{
    
    //Maptile database  instance
    CLookupMapTileDatabase* mapTileDatabase = NULL;

    TRAPD( err, mapTileDatabase = CLookupMapTileDatabase::NewL(
            KMapTileLookupDatabaseName ) );

    if ( KErrNone == err )
    {
        int appId = id;
        TRAP( err, aNoOfAddress = mapTileDatabase->FindNumberOfAddressL(appId) );
       
        if( err != KErrNone )
        {
            aNoOfAddress = 0;
        }
            
        aLookupItem.iUid = id;
        switch( sourceType )
        {
           case AddressPreference:
               aLookupItem.iSource = ESourceContactsPref;
               break;
           case AddressWork:
               aLookupItem.iSource = ESourceContactsWork;
               break;
           case AddressHome:
               aLookupItem.iSource = ESourceContactsHome;
               break;
           default: 
               break;
        }
   
        TRAP( err , mapTileDatabase->FindEntryL( aLookupItem ) );
        
        //delet the database instance
        delete mapTileDatabase;
           
    }
    
    return err;
}

// End of file