/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This program 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, version 2.1 of the License.
* 
* This program 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 program.  If not, 
* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
*
* Description:
*
*/

#include "xqsysinfo_p.h"
#include "xqsysinfo.h"
#include "cdeviceinfo.h"
#include <e32const.h> 
#include <sysutil.h>
#include <etel3rdparty.h> 
#include <f32file.h>
#include <featdiscovery.h> 

XQSysInfoPrivate::XQSysInfoPrivate(XQSysInfo *sysInfo) : q(sysInfo)
{
    TRAP(iError, iDeviceInfo = CDeviceInfo::NewL();)
}

XQSysInfoPrivate::~XQSysInfoPrivate()
{
    delete iDeviceInfo;
}

XQSysInfo::Language XQSysInfoPrivate::currentLanguage() const
{
    return static_cast<XQSysInfo::Language>(User::Language());
}

QString XQSysInfoPrivate::imei() const
{
    TBuf<CTelephony::KPhoneSerialNumberSize> imei(iDeviceInfo->imei());
    return QString::fromUtf16(imei.Ptr(), imei.Length());
}

QString XQSysInfoPrivate::model() const
{
    TBuf<CTelephony::KPhoneModelIdSize> model(iDeviceInfo->model());
    return QString::fromUtf16(model.Ptr(), model.Length());
}

QString XQSysInfoPrivate::manufacturer() const
{
    TBuf<CTelephony::KPhoneModelIdSize> manufacturer(
            iDeviceInfo->manufacturer());
    return QString::fromUtf16(manufacturer.Ptr(), manufacturer.Length()); 
}

QString XQSysInfoPrivate::imsi() const
{   
    TBuf<CTelephony::KIMSISize> imsi(iDeviceInfo->imsi());
    return QString::fromUtf16(imsi.Ptr(), imsi.Length()); 
}

QString XQSysInfoPrivate::softwareVersion() const
{
    QString version;
    TBuf<KSysUtilVersionTextLength> versionBuf;
    if (SysUtil::GetSWVersion(versionBuf) == KErrNone) {
        version = QString::fromUtf16(versionBuf.Ptr(), versionBuf.Length());
    }
    return version;
}

uint XQSysInfoPrivate::batteryLevel() const
{
    return iDeviceInfo->batteryLevel();
}

int XQSysInfoPrivate::signalStrength() const
{
    return iDeviceInfo->signalStrength();
}

int XQSysInfoPrivate::memory() const
{
    TMemoryInfoV1Buf info;
    UserHal::MemoryInfo(info);
    return info().iFreeRamInBytes;    
}

QString XQSysInfoPrivate::browserVersion() const
{
    return QString();
}

qlonglong XQSysInfoPrivate::diskSpace(XQSysInfo::Drive drive)
{
    RFs fsSession;
    TInt64 driveFreeSize = 0;
    TRAP(iError,
        CleanupClosePushL(fsSession);
        User::LeaveIfError(fsSession.Connect()); 
        int driveIndex = static_cast<TDriveNumber>(drive);
        
        if (fsSession.IsValidDrive(driveIndex)) {
            TDriveInfo driveInfo;
            User::LeaveIfError(fsSession.Drive(driveInfo, driveIndex));
            TVolumeInfo volumeInfo;
            User::LeaveIfError(fsSession.Volume(volumeInfo, driveIndex));
            driveFreeSize = volumeInfo.iFree;
        }
        CleanupStack::PopAndDestroy(&fsSession);
    )
    return driveFreeSize;
}

bool XQSysInfoPrivate::isDiskSpaceCritical(XQSysInfo::Drive drive) const
{
    bool isCritical = false;

    TRAP(iError,
        int driveIndex = static_cast<TDriveNumber>(drive);
        
        RFs fsSession;
        CleanupClosePushL(fsSession);
        if (fsSession.IsValidDrive(driveIndex)) {
            User::LeaveIfError(fsSession.Connect());
        
            if (SysUtil::DiskSpaceBelowCriticalLevelL(
                    &fsSession, 0, driveIndex)) {
                isCritical = true;
            } else {
                isCritical = false;
            }
        } else {
            User::Leave(KErrNotFound);
        }
        CleanupStack::PopAndDestroy(&fsSession);
    )
    return isCritical;
}

bool XQSysInfoPrivate::isSupported(int featureId)
{
    bool isFeatureSupported = false;
    TRAPD(iError, isFeatureSupported = CFeatureDiscovery::IsFeatureSupportedL(featureId);) //insp: major, error checking is not reliable
    return isFeatureSupported;
}

void XQSysInfoPrivate::SignalStatusL(TInt32 aStrength, TInt8 /*aBars*/)
{
    emit q->networkSignalChanged(aStrength);
}

void XQSysInfoPrivate::BatteryLevelL(TUint aChargeLevel, CTelephony::TBatteryStatus /*aBatteryStatus*/)
{
    emit q->batteryLevelChanged(aChargeLevel);
}

bool XQSysInfoPrivate::isNetwork() const
{
    return (signalStrength() != 0);
}

XQSysInfo::Error XQSysInfoPrivate::error() const
{
    switch (iError) {
    case KErrNone:
        return XQSysInfo::NoError;
    case KErrNoMemory:
        return XQSysInfo::OutOfMemoryError;
    case KErrNotFound:
        return XQSysInfo::DriveNotFoundError;
    default:
        return XQSysInfo::UnknownError;
    }   
}