/*
* 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:
*
*/
#include "simutility.h"
#include <mmtsy_names.h>
#include <startupdomainpskeys.h>
#include <e32property.h>

SimUtility::SimUtility(StoreType type, int& error, QObject *parent)
    : QObject(parent),
    m_etelStoreInfoPckg(m_etelStoreInfo),
    m_serviceTablePckg(m_serviceTable),
    m_asyncWorker(NULL),
    m_activeRequest(ENoActiveRequest),
    m_securitySettings(NULL)
{
#ifdef __WINS__
    error = KErrNotSupported;
    return;
#endif

    error = m_etelServer.Connect();
    if (error == KErrNone) {
        error = m_etelServer.LoadPhoneModule(KMmTsyModuleName);
    }
    if (error == KErrNone) {
        RTelServer::TPhoneInfo info;
        error = m_etelServer.GetPhoneInfo(0, info);
        if (error == KErrNone) {
            error = m_etelPhone.Open(m_etelServer, info.iName);
        }
    }
    if (error == KErrNone) {
        // open specified Etel store
        if (type == AdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccAdnPhoneBook);
        }
        else if (type == SdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccSdnPhoneBook);
        }
        else if (type == FdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccFdnPhoneBook);
        }
        else {
            error = KErrNotSupported;
        }
    }
    
    if (error == KErrNone) {
        error = m_customPhone.Open(m_etelPhone);
    }
    
    if (error == KErrNone) {
        TRAP(error, 
                m_asyncWorker = new (ELeave)AsyncWorker(this);
                TSecUi::InitializeLibL();
                m_securitySettings = CSecuritySettings::NewL();
            );
    }
}

SimUtility::~SimUtility()
{
    m_etelStore.Close();
    m_etelPhone.Close();
    m_etelServer.Close();

    delete m_asyncWorker;
    delete m_securitySettings;
    TSecUi::UnInitializeLib();
}

SimUtility::SimInfo SimUtility::getSimInfo(int& error)
{
    TRequestStatus requestStatus;
    m_etelStore.GetInfo(requestStatus, (TDes8&)m_etelStoreInfoPckg);
    User::WaitForRequest(requestStatus);
    error = requestStatus.Int();
    SimInfo results;
    
    if (error == KErrNone) {
        results.totalEntries = m_etelStoreInfo.iTotalEntries;
        results.usedEntries = m_etelStoreInfo.iUsedEntries;
        results.maxNumLength = m_etelStoreInfo.iMaxNumLength;
        results.maxTextLength = m_etelStoreInfo.iMaxTextLength;
        results.maxSecondNames = m_etelStoreInfo.iMaxSecondNames;
        results.maxTextLengthSecondName = m_etelStoreInfo.iMaxTextLengthSecondName;
        results.maxAdditionalNumbers = m_etelStoreInfo.iMaxAdditionalNumbers;
        results.maxNumLengthAdditionalNumber = m_etelStoreInfo.iMaxNumLengthAdditionalNumber;
        results.maxTextLengthAdditionalNumber = m_etelStoreInfo.iMaxTextLengthAdditionalNumber;
        results.maxGroupNames = m_etelStoreInfo.iMaxGroupNames;
        results.maxTextLengthGroupName = m_etelStoreInfo.iMaxTextLengthGroupName;
        results.maxEmailAddr = m_etelStoreInfo.iMaxEmailAddr;
        results.maxTextLengthEmailAddr = m_etelStoreInfo.iMaxTextLengthEmailAddr;
    }
    return results;
}

SimUtility::AvailableStores SimUtility::getAvailableStores(int& error)
{
    AvailableStores availableStores;
    if (!isSimInserted()) {
        error = KErrNone;
        return availableStores;
    }
    
    m_serviceTableType = RMobilePhone::ESIMServiceTable;
    unsigned long int iccCaps;
    TRequestStatus requestStatus;
    
    int result = m_etelPhone.GetIccAccessCaps(iccCaps);
    if (result == KErrNone && (iccCaps & RMobilePhone::KCapsUSimAccessSupported)) {
        m_serviceTableType = RMobilePhone::EUSIMServiceTable;
    }

    m_etelPhone.GetServiceTable(requestStatus, m_serviceTableType, m_serviceTablePckg);
    User::WaitForRequest(requestStatus);
    error = requestStatus.Int();
    
    if (error == KErrNone) {
        //parse service table to find what stores are supported
         ParseServiceTable(&availableStores);
    }
    return availableStores;
}

bool SimUtility::verifyPin2Code()
{
    bool verified = false;
    TRAP_IGNORE(verified = m_securitySettings->AskPin2L(););
    return verified;
}

bool SimUtility::isFdnActive()
{
    RMobilePhone::TMobilePhoneFdnStatus fdnStatus;
    (void)m_etelPhone.GetFdnStatus(fdnStatus);
    if (fdnStatus == RMobilePhone::EFdnActive ||
        fdnStatus == RMobilePhone::EFdnPermanentlyActive) {
        return true;
        }
    return false;
}

int SimUtility::setFdnStatus(bool activated)
{
    RMobilePhone::TMobilePhoneFdnSetting fdnStatus = RMobilePhone::EFdnSetOff;
    if (activated) {
        fdnStatus = RMobilePhone::EFdnSetOn;
    }
    TRequestStatus status;
    m_etelPhone.SetFdnSetting(status, fdnStatus);
    User::WaitForRequest(status);
    return status.Int();
}

bool SimUtility::startGetSimInfo()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    
    m_etelStore.GetInfo(m_asyncWorker->iStatus, (TDes8&)m_etelStoreInfoPckg);
    m_asyncWorker->SetActive();
    m_activeRequest = EGetInfo;
    return true;
}

bool SimUtility::startGetAvailableStores()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    
    if (!isSimInserted()) {
        AvailableStores availableStores;
        emit availableStoresReady(availableStores, KErrNone);
        return true;
    }
    
    m_serviceTableType = RMobilePhone::ESIMServiceTable;
    unsigned long int iccCaps;
    TRequestStatus requestStatus;
    
    int result = m_etelPhone.GetIccAccessCaps(iccCaps);
    if (result == KErrNone && (iccCaps & RMobilePhone::KCapsUSimAccessSupported)) {
        m_serviceTableType = RMobilePhone::EUSIMServiceTable;
    }
    m_etelPhone.GetServiceTable(m_asyncWorker->iStatus, m_serviceTableType, m_serviceTablePckg);
    m_asyncWorker->SetActive();
    m_activeRequest = EGetAvailableStores;
    return true;
}

bool SimUtility::notifyAdnCacheStatus()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    CacheStatus cacheStatus;
    
    //check current cache status
    TRequestStatus requestStatus;
    RMmCustomAPI::TPndCacheStatus pndStatus;
    TName storeName;
    storeName.Copy(KETelIccAdnPhoneBook);
    m_customPhone.GetPndCacheStatus(requestStatus, pndStatus, storeName);
    User::WaitForRequest(requestStatus);
    if (requestStatus.Int() != KErrNone) {
        return false;
    }
    
    if (pndStatus == RMmCustomAPI::ECacheReady ||
        pndStatus == RMmCustomAPI::ECacheNotUsed) {
        cacheStatus = ECacheReady;
        emit adnCacheStatusReady(cacheStatus, KErrNone);
        return true;
        }
    else if (pndStatus == RMmCustomAPI::ECacheFailed) {
        cacheStatus = ECacheFailed;
        emit adnCacheStatusReady(cacheStatus, KErrNone);
        return true;    
        }
    else if (pndStatus == RMmCustomAPI::ECacheNotReady) {
        //wait for cache notification
        m_customPhone.NotifyPndCacheReady(m_asyncWorker->iStatus, m_etelStoreNameCached);
        m_asyncWorker->SetActive();
        m_activeRequest = EGetCacheStatus;
        return true;
    }
    else {
        return false;
    }
}

void SimUtility::RequestCompleted(int error)
{
    if (m_activeRequest == EGetInfo) {
        SimInfo results;
        if (error == KErrNone) {
            results.totalEntries = m_etelStoreInfo.iTotalEntries;
            results.usedEntries = m_etelStoreInfo.iUsedEntries;
            results.maxNumLength = m_etelStoreInfo.iMaxNumLength;
            results.maxTextLength = m_etelStoreInfo.iMaxTextLength;
            results.maxSecondNames = m_etelStoreInfo.iMaxSecondNames;
            results.maxTextLengthSecondName = m_etelStoreInfo.iMaxTextLengthSecondName;
            results.maxAdditionalNumbers = m_etelStoreInfo.iMaxAdditionalNumbers;
            results.maxNumLengthAdditionalNumber = m_etelStoreInfo.iMaxNumLengthAdditionalNumber;
            results.maxTextLengthAdditionalNumber = m_etelStoreInfo.iMaxTextLengthAdditionalNumber;
            results.maxGroupNames = m_etelStoreInfo.iMaxGroupNames;
            results.maxTextLengthGroupName = m_etelStoreInfo.iMaxTextLengthGroupName;
            results.maxEmailAddr = m_etelStoreInfo.iMaxEmailAddr;
            results.maxTextLengthEmailAddr = m_etelStoreInfo.iMaxTextLengthEmailAddr;
        }
        emit simInfoReady(results, error);
    }//EGetInfo
    else if (m_activeRequest == EGetAvailableStores) {
        AvailableStores availableStores;
        if (error == KErrNone) {
            //parse service table to find what stores are supported
            ParseServiceTable(&availableStores);
        }
        emit availableStoresReady(availableStores, error);
    }//EGetAvailableStores
    else if (m_activeRequest == EGetCacheStatus) {
        if ( m_etelStoreNameCached.Compare(KETelIccAdnPhoneBook) == 0) {
            //ADN cache is ready
            CacheStatus cacheStatus;
            if (error != KErrNone) {
                cacheStatus = ECacheFailed;
                emit adnCacheStatusReady(cacheStatus, error);
            }
            else {
                cacheStatus = ECacheReady;
                emit adnCacheStatusReady(cacheStatus, error);
            }
        }
        else {
            //another store is cached, continue listening for ADN cache
            notifyAdnCacheStatus();
        }
    }//EGetCacheStatus
    
    if (!m_asyncWorker->IsActive()) {
        m_activeRequest = ENoActiveRequest;
    }
}

void SimUtility::ParseServiceTable(AvailableStores* availableStores) const
{
    availableStores->SimPresent = true;
    if (m_serviceTableType == RMobilePhone::EUSIMServiceTable) {
        //ADN store is always present if SIM card is inserted
        availableStores->AdnStorePresent = true;
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KUstSDN ) {
            availableStores->SdnStorePresent = true;
        }
        else {
            availableStores->SdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KUstFDN) {
            availableStores->FdnStorePresent = true;
        }
        else {
            availableStores->FdnStorePresent = false;
        }
    }
    else if (m_serviceTableType == RMobilePhone::ESIMServiceTable) {
        //ADN store is always present if SIM card is inserted
        availableStores->AdnStorePresent = true;
        
        if (m_serviceTable.iServices17To24 & RMobilePhone::KSstSDN) {
            availableStores->SdnStorePresent = true;
        }
        else {
            availableStores->SdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KSstFDN) {
            availableStores->FdnStorePresent = true;
        }
        else {
            availableStores->FdnStorePresent = false;
        }
    }
}
    
bool SimUtility::isSimInserted() const
{
    bool result = false;
    
    RProperty property;   
    int simStatus = KErrNotFound;
    
    int ret = property.Get(KPSUidStartup, KPSSimStatus, simStatus);
    if (simStatus == ESimUsable && ret == KErrNone) {
        result = true;
        }
    
    property.Close();
    return result;
}