/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:   HG VOD utility class*

*/

#include <AknUtils.h>

#include <avkon.rsg>

#include <gulicon.h>

#include <cemailaccounts.h>

#include <CMessageData.h>

#include <eikenv.h>

#include <sendui.h>

#include <SendUiConsts.h>

#include <StringLoader.h>

#include <txtrich.h>

#include <tz.h>

#include <utf.h>

#include "vcxnscategory.h"

#include <vcxhgvodui.rsg>

#include "vcxhgvodutils.h"

//CONSTANTS

const TInt KVcxNsVideoSizeGB     = 0x40000000;

const TInt KVcxNsVideoSizeHalfGB = 0x20000000;

const TInt KVcxNsVideoSizeMB     = 0x100000;

const TInt KVcxNsVideoSizeHalfMB = 0x80000;

const TInt KVcxNsVideoSizeKB     = 0x400;

const TInt KVcxNsVideoSizeHalfKB = 0x200; 

const TInt KVcxNsHourInSeconds   = 3600;

const TInt KVcxNsMinuteInSeconds = 60;

const TInt KVcxNsLengthNumbersArraySize = 2;

_LIT(KVcxNsComma, ", ");

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

// CVcxHgVodUtils::~CVcxHgVodUtils()

// Destructor

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

//

CVcxHgVodUtils::~CVcxHgVodUtils()

    {

    }

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

// CVcxHgVodUtils::CVcxHgVodUtils()

// Constructor

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

//

CVcxHgVodUtils::CVcxHgVodUtils( )

    {

    }

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

//       Landscape    Portrait

// QVGA  320x240  or  240x320

// QHD   640x360  or  360x640

// VGA   640x480  or  480x640

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

//

CVcxHgVodUtils::TVcxScreenResolution CVcxHgVodUtils::GetScreenResolution( 

        CCoeEnv* aCoeEnv )

    {

    TVcxScreenResolution resolution( EVcxScreenResolutionUnknown );

    TSize screenSize = aCoeEnv->ScreenDevice()->SizeInPixels(); 

    TBool landscape = screenSize.iWidth > screenSize.iHeight;

    if ( ( landscape && screenSize.iHeight <= 240 ) ||

         ( ! landscape && screenSize.iWidth <= 240 ) )

        {

        resolution = EVcxScreenResolutionQVGA;

        }

    else if ( ( landscape && screenSize.iHeight <= 360 ) ||

              ( ! landscape && screenSize.iWidth <= 360 ) )

        {

        resolution = EVcxScreenResolutionQHD;

        }

    else if ( ( landscape && screenSize.iHeight <= 480 ) ||

              ( ! landscape && screenSize.iWidth <= 480 ) )

        {

        resolution = EVcxScreenResolutionVGA;

        }

    return resolution;

    }

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

// CVcxHgVodUtils::LoadStringFromResourceLC

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

//

HBufC* CVcxHgVodUtils::LoadStringFromResourceLC( TInt aResourceId )

    {

    return StringLoader::LoadLC( aResourceId );

    }

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

// CVcxHgVodUtils::LoadStringFromResourceLC

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

//

HBufC* CVcxHgVodUtils::LoadStringFromResourceLC( 

    TInt aResourceId, const TDesC& aDesc )

    {

    return StringLoader::LoadLC( aResourceId, aDesc );

    }

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

// CVcxHgVodUtils::LoadStringFromResourceLC

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

//

HBufC* CVcxHgVodUtils::LoadStringFromResourceLC( TInt aResourceId, const TInt aNum )

    {

    return StringLoader::LoadLC( aResourceId, aNum );

    }

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

// CVcxHgVodUtils::FormatDateAndTimeL()

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

//

void CVcxHgVodUtils::FormatDateAndTimeL( 

    TTime& aTime, 

    TDes& aFormattedString )

    {    

    TTime pubDate(aTime);

    aFormattedString.Zero();

    //Convert GMT time to local time

    RTz rtz;

    User::LeaveIfError( rtz.Connect() );

    CleanupClosePushL( rtz );

    User::LeaveIfError( rtz.ConvertToLocalTime( pubDate ) );

    CleanupStack::PopAndDestroy( &rtz );

    HBufC* dateFormatString = StringLoader::LoadLC( R_QTN_DATE_USUAL ); 

    HBufC* timeFormatString = StringLoader::LoadLC( R_QTN_TIME_USUAL ); 

    TBuf<KVcxNsMaxDateBufSize> dateString;

    // Format the date to user readable format. 

    // The format is locale dependent

    pubDate.FormatL( dateString, *dateFormatString );  

    aFormattedString.Append( dateString ); 

    aFormattedString.Append( KVcxNsSpaceString ); 

    TBuf<KVcxNsMaxTimeBufSize> timeString;

    // Format the time to user readable format.

    // The format is locale dependent

    pubDate.FormatL( timeString, *timeFormatString );  

    aFormattedString.Append( timeString ); 

    AknTextUtils::LanguageSpecificNumberConversion( aFormattedString );

    CleanupStack::PopAndDestroy( timeFormatString );

    CleanupStack::PopAndDestroy( dateFormatString );

    }

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

// CVcxHgVodUtils::FormatLengthAndSizeL()

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

//

void CVcxHgVodUtils::FormatLengthAndSizeL( 

    TUint32 aLength, 

    TUint32 aSize, 

    TDes& aFormattedString )

    {

    aFormattedString.Zero();

    if ( aLength > 0 )

        {

        HBufC* videoLength;

        TInt hours  = aLength / KVcxNsHourInSeconds;

        TInt minutes = ( aLength - ( hours * KVcxNsHourInSeconds ) ) / KVcxNsMinuteInSeconds;

        if ( hours > 0 )

            {

            CArrayFix<TInt>* numbers = 

                new (ELeave) CArrayFixFlat<TInt>(KVcxNsLengthNumbersArraySize); 

            CleanupStack::PushL( numbers );

            numbers->AppendL( hours );

            numbers->AppendL( minutes );

            videoLength = StringLoader::LoadLC( R_VCXHG_VIDEOLENGTH_FULL, *numbers ); 

            aFormattedString.Append( *videoLength );

            CleanupStack::PopAndDestroy( videoLength );

            CleanupStack::PopAndDestroy( numbers ); 

            }

        else 

            {

            if ( hours == 0 && minutes == 0 )

                {

                minutes = 1;

                }

            videoLength = StringLoader::LoadLC( R_VCXHG_VIDEOLENGTH_MIN, minutes ); 

            aFormattedString.Append( *videoLength );

            CleanupStack::PopAndDestroy( videoLength );

            }                        

        }    

    if ( aSize > 0 )

        {

        if ( aFormattedString.Length() > 0  )

            {

            aFormattedString.Append( KVcxNsComma ); //add comma separator 

            }

        HBufC* videosize;

        TUint dispSize;

        if ( aSize >= KVcxNsVideoSizeGB )                    // 1 GB 

            {

            dispSize  = aSize + KVcxNsVideoSizeHalfGB;       // ½ GB 

            dispSize /= KVcxNsVideoSizeGB;

            videosize   = StringLoader::LoadLC( R_VCXHG_VIDEOSIZE_GB, dispSize );

            }

        else if ( aSize >= KVcxNsVideoSizeMB )               // 1 MB 

            {

            dispSize  = aSize + KVcxNsVideoSizeHalfMB;       // ½ MB 

            dispSize /= KVcxNsVideoSizeMB;

            videosize   = StringLoader::LoadLC( R_VCXHG_VIDEOSIZE_MB, dispSize );

            }

        else

            {

            dispSize  = aSize + KVcxNsVideoSizeHalfKB;       // ½ kB 

            dispSize /= KVcxNsVideoSizeKB;                           

            if ( dispSize == 0 ) 

                {

                dispSize = 1;

                }

            videosize = StringLoader::LoadLC( R_VCXHG_VIDEOSIZE_KB, dispSize );

            }

        aFormattedString.Append( *videosize );

        CleanupStack::PopAndDestroy( videosize );

        }

    }

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

// CVcxHgVodUtils::FormatDownloadStateL()

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

//

void CVcxHgVodUtils::FormatDownloadStateL( 

    CVcxNsContent::TVcxContentDlStatus aStatus,

    TInt aProgress,

    TDes& aFormattedString )

    {

    aFormattedString.Zero();

    HBufC* desString = NULL;

    switch( aStatus )

        {

        case CVcxNsContent::EVcxContentDlStateDownloading:

            {

            desString = StringLoader::LoadLC( R_IPTV_VIDEO_DOWNLOADING, aProgress );

            }

            break;

        case CVcxNsContent::EVcxContentDlStateFailed:

            {

            desString = StringLoader::LoadLC( R_IPTV_DOWNLOAD_FAILED, aProgress );

            }

            break;

        case CVcxNsContent::EVcxContentDlStatePaused:

            {

            desString = StringLoader::LoadLC( R_IPTV_DOWNLOAD_PAUSED, aProgress );

            }

            break;

        case CVcxNsContent::EVcxContentDlStateDownloaded:

            {

            desString = StringLoader::LoadLC( R_IPTV_VIDEO_DOWNLOADED );

            }

            break; 

        default:

            {

            desString = KNullDesC().AllocLC();

            }

            break;

        }

    aFormattedString.Append( *desString );

    CleanupStack::PopAndDestroy( desString );

    }

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

// 

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

//

TBool CVcxHgVodUtils::IsSearchCategory( CVcxNsCategory& aCategory )

    {

    return aCategory.GetCategoryId() == KVcxNsSearchCategoryId ? ETrue : EFalse;

    }

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

// 

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

//

HBufC* CVcxHgVodUtils::ResolveCategoryNameLC( CVcxNsCategory& aCategory )

    {

    if ( IsSearchCategory( aCategory ) )

        {

        return LoadStringFromResourceLC( R_VCXHG_VIDEO_SEARCH );

        }

    else if ( aCategory.GetName().Length() == 0 )

        {

        return LoadStringFromResourceLC( R_VCXHG_CATEGORIES_VIDEO_LIST );

        }

    else

        {

        return aCategory.GetName().AllocLC();

        }

    }

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

// 

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

//

HBufC* CVcxHgVodUtils::ResolveCategoryInfoLC( CVcxNsCategory& aCategory )

    {

    if( IsSearchCategory( aCategory ) )

        {

        if( aCategory.GetVideoCount() == 0 )

            {

            return HBufC::NewLC(0);

            }

        else if( aCategory.GetVideoCount() == 1 )

            {

            return LoadStringFromResourceLC( R_VCXHG_SEARCH_VIDEOS_FOUND_ONE );

            }

        else

            {

            return LoadStringFromResourceLC( R_VCXHG_SEARCH_VIDEOS_FOUND, 

                                             aCategory.GetVideoCount() );            

            }

        }

    else

        {

        if( aCategory.GetVideoCount() == 1 )

            {

            return LoadStringFromResourceLC( R_VCXHG_ONE_VIDEO_IN_CATEGORY );

            }

        else

            {

            return LoadStringFromResourceLC( R_VCXHG_VIDEOS_IN_CATEGORY,

                                             aCategory.GetVideoCount() );            

            }

        }

    }

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

// CVcxHgVodUtils::IsDefaultSmtpAccountDefinedL()

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

//

TBool CVcxHgVodUtils::IsDefaultSmtpAccountDefinedL()

    {

    CEmailAccounts* mailAccounts = CEmailAccounts::NewLC();

    TSmtpAccount account;

    TInt error = mailAccounts->DefaultSmtpAccountL( account );

    CleanupStack::PopAndDestroy( mailAccounts );

    return ( KErrNone == error );

    }

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

// CVcxHgVodUtils::ShareLinkL()

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

//

void CVcxHgVodUtils::ShareLinkL(

    const TDesC& aLink,

    const TUid aMessageTypeModule,

    CEikonEnv& aEikonEnv )

    {

    CSendUi* sendUi = CSendUi::NewLC();

    TInt linkLength = aLink.Length();

    // Must be able to send at least linkLength long body text,

    // make sure it's supported

    TSendingCapabilities sendingCapabilities(

        linkLength, linkLength, TSendingCapabilities::ESupportsBodyText );

    if ( sendUi->ValidateServiceL( aMessageTypeModule, sendingCapabilities ) )

        {

        CMessageData* message = CMessageData::NewLC();

        CRichText* richText = CRichText::NewL(

                aEikonEnv.SystemParaFormatLayerL(),

                aEikonEnv.SystemCharFormatLayerL() );

        CleanupStack::PushL( richText );

        richText->InsertL( 0, aLink );

        message->SetBodyTextL( richText );

        sendUi->CreateAndSendMessageL(

                aMessageTypeModule,

                message,

                KNullUid,

                EFalse ); // ETrue:  Open in embedded mode

                          // EFalse: Do not embed message editor

        CleanupStack::PopAndDestroy( richText );

        CleanupStack::PopAndDestroy( message );

        }

    else

        {

        // Sending link with aServiceUid is not supported

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PopAndDestroy( sendUi );

    }

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

// CVcxHgVodUtils::DuplicateGulIconL()

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

//

CGulIcon* CVcxHgVodUtils::DuplicateGulIconL( CGulIcon* aIcon )

    {

    CFbsBitmap* icon = new (ELeave) CFbsBitmap;

    CleanupStack::PushL( icon );

    CFbsBitmap* mask = NULL;

    icon->Duplicate( aIcon->Bitmap()->Handle() );

    if ( aIcon->Mask() )

        {

        mask = new (ELeave) CFbsBitmap();

        CleanupStack::PushL( mask );

        mask->Duplicate( aIcon->Mask()->Handle() );

        }

    CGulIcon* newIcon = CGulIcon::NewL( icon, mask );

    if ( mask )

        {

        CleanupStack::Pop( mask );

        }

    CleanupStack::Pop( icon );

    return newIcon;

    }