/*

* Copyright (c) 2002-2006 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:   BIO control for Ringing Tones.

*

*/

// INCLUDE FILES

#include "RingingToneBioControl.h"      // for CRingingToneBioControl

#include "RingBCToneConverter.h"             // for CComNSMConverter

#include "RingBC.hrh"

#include "RingBCLog.h"

#include <biocmtm.h>                    // for CBIOClientMtm

#include <coeutils.h>                   // for ConeUtils

#include <msgbiocontrolObserver.h>      // for MMsgBioControlObserver

#include <StringLoader.h>               // for StringLoader

#include <AknsUtils.h>

#include <RingBC.rsg>                   // for resouce identifiers

#include <ringbc.mbg>                   // for icons indexes

#include <ProfileEngineSDKCRKeys.h>

#include <MsgBioUtils.h>                // for MsgBioUtils

#include <eikrted.h>                    // for CEikRichTextEditor

#include <txtrich.h>                    // for CRichText

#include <aknnotewrappers.h>            // for CAknInformationNote

#include <Profile.hrh>                  // for EProfileRingingTypeSilent

#include <bldvariant.hrh>

#include <pathinfo.h>

#include <featmgr.h>					// Feature manager

#include <csxhelp/smart.hlp.hrh>

#include <data_caging_path_literals.hrh>

#include <applayout.cdl.h>				// LAF

#include <aknlayoutscalable_apps.cdl.h>

#include <mmsvattachmentmanager.h>

#include <msgaudiocontrol.h>	//AudioControl

#include <MsgEditorCommon.h>	//MsgEditorCommons utilities

// CONSTANTS

_LIT(KRingingToneFileExtension,".rng");

_LIT(KResourceName, "ringbc.rsc" );

_LIT(KRingBCMbmFileName, "ringbc.mif");

// LOCAL CONSTANTS AND MACROS

const TInt KComponentCountZero = 0;

const TInt KNoOverWriteOrRecurse = 0;

const TInt KLengthOfTitleRow = 100;

const TInt KTextNameQueryMaxLength = 50;

const TInt KRichEditor              = 1;

const TInt KAudioControl            = 0;

const TInt KRingVolumeZero = 0;

const TInt KShowNoNotes = 0;

const TInt KShowNotes = 1;

const TInt KFrameExpansion = 10;

// MODULE DATA STRUCTURES

enum TOptionListLocation

    {

    EFirstMenuItem  = 0,

    ESecondMenuItem

    };

// ================= MEMBER FUNCTIONS =======================

// Two-phased constructor.

EXPORT_C CMsgBioControl* CRingingToneBioControl::NewL(

            MMsgBioControlObserver& aObserver,

            CMsvSession* aSession,

            TMsvId aId,

            TMsgBioMode aEditorOrViewerMode,

            const RFile* aFile)

    {

    CRingingToneBioControl* self =

    	new( ELeave ) CRingingToneBioControl(

    		aObserver,

            aSession, aId, aEditorOrViewerMode,

            aFile);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self); // self

    return self;

    }

// Destructor

CRingingToneBioControl::~CRingingToneBioControl()

    {

    FeatureManager::UnInitializeLib();

    delete iRichEditor;

    delete iAudioControl;    

    delete iToneTitle;

    }

// C++ default constructor.

CRingingToneBioControl::CRingingToneBioControl(

        MMsgBioControlObserver& aObserver,

        CMsvSession* aSession,

        TMsvId aId,

        TMsgBioMode aEditorOrViewerMode,

        const RFile* aFile):

        CMsgBioControl(aObserver,

            aSession,

            aId,

            aEditorOrViewerMode,

            aFile)

    {

    }

// Symbian OS default constructor can leave.

void CRingingToneBioControl::ConstructL()

    {

    if( IsEditor() )   //Editor mode is not supported

        {

        User::Leave( KErrNotSupported );

        }

	FeatureManager::InitializeLibL();

    LoadStandardBioResourceL();

    LoadResourceL( KResourceName );

    // checks if the message is valid

    CheckMsgValidityL();

    TakeTitleL();

    }

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

// CRingingToneBioControl::CheckMsgValidityL

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

//

void CRingingToneBioControl::CheckMsgValidityL()

    {

    RFile file;

    CMsvEntry* entry = this->MsvSession(). GetEntryL(iId);

    CleanupStack::PushL( entry );

    CMsvStore* store = entry->ReadStoreL();

	CleanupStack::PushL(store);

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	file = manager.GetAttachmentFileL(0);

    CleanupClosePushL(file);

    TInt size;

    User::LeaveIfError(file.Size(size));

    if (!size)

        {

        //the empty ringing tone is considered a corrupted message

        User::Leave(KErrMsgBioMessageNotValid);

        }

	HBufC8* dataBuf = HBufC8::NewLC(size);

    TPtr8 data(dataBuf->Des());

    User::LeaveIfError(file.Read(data, size));

    CRingBCNSMConverter* conv = CRingBCNSMConverter::NewL();

    CleanupStack::PushL( conv );

    TBool res = conv->IsRingToneMimeTypeL(data);

    if (!res)

        {

        User::Leave(KErrMsgBioMessageNotValid);

        }

    CleanupStack::PopAndDestroy(5,entry); // entry,conv,store,file,dataBuf

    }

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

// CRingingToneBioControl::ProcessCommandL

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

//

void CRingingToneBioControl::ProcessCommandL( TInt aCommandId )

    {

    if ( aCommandId == ESoftkeyStop )

		{

		StopPlayback();

        }

    }

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

// CRingingToneBioControl::SetAndGetSizeL

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

//

void CRingingToneBioControl::SetAndGetSizeL( TSize& aSize )

    {

	//the heightadjustment calculates the height for the header elements and 

	//the space between components

   	TInt heightAdjustment = (MsgEditorCommons::MsgBaseLineDelta()*2)+

   							MsgEditorCommons::MsgBaseLineOffset();

   	aSize.iHeight -= heightAdjustment;

   	SetSizeWithoutNotification( aSize  );

    }

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

// CRingingToneBioControl::SetMenuCommandSetL

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

//

void CRingingToneBioControl::SetMenuCommandSetL( CEikMenuPane& aMenuPane )

    {

    // if playing, do not show context sensitive menu.

    if ( iPlayerState != EMsgAsyncControlStatePlaying )

        {

        AddMenuItemL(aMenuPane, R_SM_PLAYBACK, ERingtPlayback, EFirstMenuItem);

        AddMenuItemL(aMenuPane,

        	R_SM_ADD_COMPOSER, ERingtAddComposer, ESecondMenuItem);

        }

	}

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

// CRingingToneBioControl::CurrentLineRect

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

//

TRect CRingingToneBioControl::CurrentLineRect() const

    {

    return iAudioControl->CurrentLineRect();

    }

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

// CRingingToneBioControl::IsFocusChangePossible

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

//

TBool CRingingToneBioControl::IsFocusChangePossible(

        TMsgFocusDirection aDirection ) const

    {

    return iAudioControl->IsFocusChangePossible( aDirection );

	}

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

// CRingingToneBioControl::HeaderTextL

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

//

HBufC* CRingingToneBioControl::HeaderTextL() const

    {

    return iCoeEnv->AllocReadResourceL( R_SM_TITLE_RINGING_TONE );

    }

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

// CRingingToneBioControl::HandleBioCommandL

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

//

TBool CRingingToneBioControl::HandleBioCommandL(TInt aCommand)

    {

    aCommand -= iBioControlObserver.FirstFreeCommand();

    TBool retValue(EFalse);

    switch ( aCommand )

        {

        case ERingtPlayback:

            PlaybackL();

            retValue = ETrue;

            break;

        case ERingtAddComposer:

            TrySaveToneL();

            retValue = ETrue;

            break;

        default:

            retValue = EFalse;

            break;

        }

	return retValue;

    }

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

// CRingingToneLogoBioControl::OptionMenuPermissionsL

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

//

TUint32 CRingingToneBioControl::OptionMenuPermissionsL() const

    {

    if ( iPlayerState != EMsgAsyncControlStatePlaying )

        {

        return EMsgBioDelete

        | EMsgBioMessInfo

        | EMsgBioMove

        | EMsgBioHelp

        | EMsgBioExit;

        }

    else 

        {

        // do not show context sensitive menu.

        return 0;

        }

    }

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

// CRingingToneBioControl::OfferKeyEventL

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

//

TKeyResponse CRingingToneBioControl::OfferKeyEventL(

        const TKeyEvent& /*aKeyEvent*/,

        TEventCode /*aType*/ )

    {

    return EKeyWasConsumed;

    }

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

// CRingingToneBioControl::GetHelpContext

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

//

void CRingingToneBioControl::GetHelpContext(

	TCoeHelpContext& aHelpContext) const

	{

	if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

		{

		const TUid KUidSmart = {0x101F4CDA};

		aHelpContext.iContext = KSMART_HLP_RINGVIEWER();

		aHelpContext.iMajor = KUidSmart;

		}

	}

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

// CRingingToneBioControl::CountComponentControls

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

//

TInt CRingingToneBioControl::CountComponentControls() const

    {

    TInt componentCount( KComponentCountZero );

    if ( iAudioControl )

        {

        componentCount++;

        }

	if ( iRichEditor )        

		{

		componentCount++;

		}

    return componentCount;

    }

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

// CRingingToneBioControl::ComponentControl

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

//

CCoeControl* CRingingToneBioControl::ComponentControl( TInt aIndex ) const

    {

    if ( aIndex == KRichEditor )

    	{

    	return iRichEditor;

    	}

    if ( aIndex == KAudioControl )

        {

        return iAudioControl;

        }

    else

    	{

    	return NULL;

    	}

	}

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

// CRingingToneBioControl::HandleResourceChange

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

//

void CRingingToneBioControl::HandleResourceChange( TInt aType )

    {

    if(aType == KEikDynamicLayoutVariantSwitch)

    	{

        TRAP_IGNORE(

       		CorrectFormatToRichEditorL();

        	iRichEditor->SetTextL( iToneTitle );

        	FillBitmapMaskL();

        	);

        }

    iAudioControl->HandleResourceChange( aType );

    }

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

// CRingingToneBioControl::SizeChanged

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

//

void CRingingToneBioControl::SizeChanged()

    {

    TRect rect = Rect();

    TRect bitmapRect;

    TAknWindowComponentLayout layout =

	   	AknLayoutScalable_Apps::mce_image_pane_g5();

    TAknLayoutRect LayoutRect;

	LayoutRect.LayoutRect( rect, layout.LayoutLine() );

	bitmapRect = LayoutRect.Rect();

	TInt formattedHeight = iRichEditor->TextLayout()->FormattedHeightInPixels();

	bitmapRect.Move(0,formattedHeight);

	//the rectangle is grown to so that focused frame is visible

	bitmapRect.Grow( KFrameExpansion, KFrameExpansion );

	// rect for richtext is positioned on the top of audio control

	rect.iBr.iY = bitmapRect.iTl.iY;

	iRichEditor->SetRect( rect );

    iAudioControl->SetRect( bitmapRect );

    }

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

// CRingingToneBioControl::FocusChanged

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

//

void CRingingToneBioControl::FocusChanged( TDrawNow aDrawNow )

    {

	iAudioControl->SetFocus(IsFocused());

	iRichEditor->FocusChanged(aDrawNow);

    }

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

// CRingingToneBioControl::SetContainerWindowL

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

//

void CRingingToneBioControl::SetContainerWindowL(

	const CCoeControl& aContainer )

    {

    CCoeControl::SetContainerWindowL( aContainer );

    //The reason for creating the audio control here is that the construction

    //requires a parent with a window. So it cannot be done in ConstructL()

    iAudioControl = CMsgAudioControl::NewL( *reinterpret_cast<CMsgEditorView*>(this), this, EMdaPriorityNormal, EMdaPriorityPreferenceQuality );

	FillBitmapMaskL();

    CreateRichEditorL();

    }

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

// CRingingToneBioControl ::Draw()

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

//

void CRingingToneBioControl::Draw(const TRect& /*aRect*/) const

    {

    }

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

// CRingingToneBioControl ::CorrectFormatToRichEditorL()

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

//

void CRingingToneBioControl::CorrectFormatToRichEditorL()

    {

    CRichText* rich = iRichEditor->RichText();

    TInt pos(rich->DocumentLength());

    // font correction.

    TCharFormat format;

    TCharFormatMask mask;

	TAknTextLineLayout editorLayout = AppLayout::Smart_Messages_Line_2( 0 );

	const CFont* editorFont = AknLayoutUtils::FontFromId( editorLayout.FontId() );

	format.iFontSpec = editorFont->FontSpecInTwips();

    TRgb textColor;

    if ( AknsUtils::GetCachedColor(

	    AknsUtils::SkinInstance(),

        textColor,

        KAknsIIDQsnTextColors,

        EAknsCIQsnTextColorsCG6 ) != KErrNone )

	    {

	    textColor = AKN_LAF_COLOR_STATIC( 215 );

	    }

    format.iFontPresentation.iTextColor = textColor;

    mask.ClearAll();

    mask.SetAttrib( EAttColor );

    mask.SetAttrib(EAttFontStrokeWeight);

    mask.SetAttrib(EAttFontHeight);

    mask.SetAttrib(EAttFontTypeface);

    rich->SetInsertCharFormatL(format, mask, pos);

    // this is needed to set ringing tone title centered.

    CParaFormat* paraFormat = CParaFormat::NewLC();

    TParaFormatMask paraMask;

    paraFormat->Reset();

    paraFormat->iHorizontalAlignment = CParaFormat::ECenterAlign;

    paraFormat->iVerticalAlignment = CParaFormat::ECenterAlign;

    paraMask.SetAttrib(EAttAlignment);

    paraMask.SetAttrib(EAttFontHeight);

    paraMask.SetAttrib(EAttColor);

    rich->ApplyParaFormatL(paraFormat, paraMask, 0, pos);

    CleanupStack::PopAndDestroy(paraFormat);

    }

void CRingingToneBioControl::OpenFileL()

	{

	RFile file;

	CMsvEntry* entry = this->MsvSession(). GetEntryL(iId);

	CleanupStack::PushL( entry );

	CMsvStore* store = entry->ReadStoreL();

	CleanupStack::PushL(store);

	MMsvAttachmentManager& manager = store->AttachmentManagerL();

	file = manager.GetAttachmentFileL(0);

	CleanupClosePushL(file);

	//asynchronous loading of file

	//the audio control takes a copy of the file

	iAudioControl->LoadL(file);

	//wait for the opening of file to complete

	//in MsgMediaControlStateChanged

    CActiveScheduler::Start();