/*
* Copyright (c) 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:  Sending remote drive configuration entries
*
*/


#include <eikenv.h>
#include <sendui.h>
#include <CMessageData.h>
#include <SendUiConsts.h>
#include <txtrich.h>
#include <utf.h> // for CnvUtfConverter
#include <StringLoader.h>
#include <AknQueryDialog.h>
#include <sysutil.h>
#include <rsfwgspluginrsc.rsg>
#include <rsfwmountentry.h>

#include "rsfwgsremotedrivesend.h"
#include "rsfwmountutils.h"
#include "rsfwgsplugin.hrh"


// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::NewL
// Static constructor
// (other items were commented in a header).
// ---------------------------------------------------------
//
CRsfwGsRemoteDriveSend* CRsfwGsRemoteDriveSend::NewL(TInt aMenuCommandId)
    {
    CRsfwGsRemoteDriveSend* self = new (ELeave) CRsfwGsRemoteDriveSend();
    CleanupStack::PushL(self);
    self->ConstructL(aMenuCommandId);
    CleanupStack::Pop(self);
    return self;
    }

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::CRsfwGsRemoteDriveSend
// C++ constructor
// (other items were commented in a header).
// ---------------------------------------------------------
//
CRsfwGsRemoteDriveSend::CRsfwGsRemoteDriveSend()
    {
    }

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::ConstructL
// 2nd phase constructor
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CRsfwGsRemoteDriveSend::ConstructL(TInt aMenuCommandId)
    {
    iSendUi = CSendUi::NewL();
    iSendAsCmdId=aMenuCommandId;
    iSendMtmsToDim = new (ELeave) CArrayFixFlat<TUid>(4);

    // for the time being, dim everything else but SMS
    // for some reason technology-group UIDs do not seem to work
    // e-mail Mtmss
    iSendMtmsToDim->AppendL(KSenduiMtmSmtpUid);
    iSendMtmsToDim->AppendL(KSenduiMtmImap4Uid);
    iSendMtmsToDim->AppendL(KSenduiMtmPop3Uid);
    
    // MMS, BT, Irda, Postcard
    iSendMtmsToDim->AppendL(KSenduiMtmMmsUid);
    iSendMtmsToDim->AppendL(KSenduiMtmPostcardUid);
    iSendMtmsToDim->AppendL(KSenduiMtmBtUid);
    iSendMtmsToDim->AppendL(KSenduiMtmIrUid);
    
    // Audio Message
    iSendMtmsToDim->AppendL(KSenduiMtmAudioMessageUid);
    
    iSendMtmsToDim->AppendL(KSenduiMtmSyncMLEmailUid  );
    
    // filters out EMail Via Exchange, as we only support SMS
    // for some reason this cannot be found from headers currently
    const TUid KEmailViaExchange        = {  0x102826F8    };
    iSendMtmsToDim->AppendL(KEmailViaExchange );
      
    }

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::~CRsfwGsRemoteDriveSend
// Destructor
// (other items were commented in a header).
// ---------------------------------------------------------
//
CRsfwGsRemoteDriveSend::~CRsfwGsRemoteDriveSend()
    {
    delete iSendUi;
    delete iSendMtmsToDim;
    }


// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::CanSendL
// Check wheter sending is possible
// (other items were commented in a header).
// ---------------------------------------------------------
//
TBool CRsfwGsRemoteDriveSend::CanSend()
    {
    if( iSelectedMtmUid != KNullUid )
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::DisplaySendMenuItemL
// Show sendui menu
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CRsfwGsRemoteDriveSend::DisplaySendMenuItemL(CEikMenuPane& aMenuPane, 
                                               TInt aIndex)
    {
    iSendUi->AddSendMenuItemL( aMenuPane, aIndex, iSendAsCmdId, TSendingCapabilities() );
    }

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::DisplaySendCascadeMenuL
// Show send quesry / cascaded menu
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CRsfwGsRemoteDriveSend::DisplaySendCascadeMenuL()
    {
    iSelectedMtmUid = iSendUi->ShowSendQueryL( NULL, KCapabilitiesForAllServices, iSendMtmsToDim, KNullDesC );
    }

    

// ---------------------------------------------------------
// CRsfwGsRemoteDriveSend::SendL
// Send a remote drive entry via SendUi
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CRsfwGsRemoteDriveSend::SendL(const CRsfwMountEntry& anEntry)
    {

    // the old entry can be deleted in the middle of the operation
    // e.g. from the File Manager
    CRsfwMountEntry* entryToBeSent = anEntry.CloneL();
    CleanupStack::PushL(entryToBeSent);
    
    CEikonEnv* eikonEnv = CEikonEnv::Static();
    CRichText* text = CRichText::NewL(
        eikonEnv->SystemParaFormatLayerL(),
        eikonEnv->SystemCharFormatLayerL());
    CleanupStack::PushL(text);
    
    
     // if user name has been set
    // ask user whether he would like to send the login credentials
    TBool sendCredentials = EFalse;
    if ((entryToBeSent->Item(EMountEntryItemUserName))->Length() > 0) 
        {
        HBufC* myDisplayMessage = NULL;
        myDisplayMessage = StringLoader::LoadLC(R_STR_RSFW_SEND_CREDENTIALS_QUERY);
        CAknQueryDialog* query = CAknQueryDialog::NewL
                                        (CAknQueryDialog::EConfirmationTone);    
        sendCredentials = 
                query->ExecuteLD( R_CONFIRMATION_QUERY, *myDisplayMessage);
        CleanupStack::PopAndDestroy(myDisplayMessage);
        }
    
    
     // Encode configuration entry
    HBufC* vcal = HBufC::NewLC(KMaxMountConfLength);
    TPtr p = vcal->Des();
    RsfwMountUtils::ExportMountEntryL(*entryToBeSent, sendCredentials, p);   
    
    // convert to 8-bit
    // note that safe conversion is needed both when sending
    // as an attachement and when sending as message text
    HBufC8* temp = ConvertToUtf7LC(p); 

    TUid mtmUid = iSelectedMtmUid;
    TSendingCapabilities capabilities;
    iSendUi->ServiceCapabilitiesL( mtmUid, capabilities );
    if (capabilities.iFlags & TSendingCapabilities::ESupportsAttachments)
        {
         // send as Attachment
        RFs fs;
        User::LeaveIfError( fs.Connect() );
        CleanupClosePushL( fs );
        // must share the handle between processes
        User::LeaveIfError( fs.ShareProtected() );
        TInt err = fs.MkDirAll(KRemoteDriveAttachmentFilename);
        RFile file;
        err = file.Replace(fs,KRemoteDriveAttachmentFilename,EFileWrite | EFileShareAny );
        CleanupClosePushL(file);
        TInt spaceNeeded = vcal->Size();
        if ( SysUtil::FFSSpaceBelowCriticalLevelL( &fs, spaceNeeded ) )
            {
            // don't show any own notes here
            User::Leave( KErrDiskFull );
            }

        User::LeaveIfError(file.Write(*temp));

        TParse parse;
        User::LeaveIfError(parse.SetNoWild(KRemoteDriveAttachmentFilename,
                                           NULL, NULL));

        CMessageData* messageData = CMessageData::NewL();
        CleanupStack::PushL( messageData );
        messageData->AppendAttachmentHandleL(file);
        iSendUi->CreateAndSendMessageL( iSelectedMtmUid, messageData, KUidBIOMountConfMsg, ETrue );
      
        CleanupStack::PopAndDestroy( 2 ); // messageData, file
        fs.Delete(parse.FullName());
        CleanupStack::PopAndDestroy( &fs );;
        }
   else
        {
        // send as message body
        // message data interface is 16-bit
        // however, along the way 8-bit interface is used 
        // to pass the data without safe conversion
        // so the unicode conversion above is still needed
        HBufC* bufCnv = HBufC::NewLC(temp->Length());
        TPtr16 des(bufCnv->Des());
        des.Copy(p);
        text->InsertL(0, des);

        CMessageData* messageData = CMessageData::NewL();
        CleanupStack::PushL( messageData );
        messageData->SetBodyTextL( text );
        iSendUi->CreateAndSendMessageL( iSelectedMtmUid, messageData, KUidBIOMountConfMsg, ETrue );
        CleanupStack::PopAndDestroy(2); // messageData, bufCnv
        }         
    
    CleanupStack::PopAndDestroy(4); // entryToBeSent, text, vcal, temp
 
    }

// ------------------------------------------------------------------------------------------------
// HBufC* CRsfwGsRemoteDriveSend::ConvertToUtf7LC
// Encodes from Unicode UCS-2 to UTF-8
// ------------------------------------------------------------------------------------------------
HBufC8* CRsfwGsRemoteDriveSend::ConvertToUtf7LC(const TDesC16& aText)
    {
    TPtrC16    remainder( aText );
    TBuf8<20>  utfBuffer;
    HBufC8     *ret    = 0;
    CBufFlat   *buffer = CBufFlat::NewL( 128 );
    CleanupStack::PushL( buffer );

    TBool finish = EFalse;
    while( !finish )
        {
        utfBuffer.Zero();
        TInt unconverted = CnvUtfConverter::ConvertFromUnicodeToUtf7(utfBuffer, remainder, EFalse );
        if( unconverted >= 0 )
            {
            remainder.Set( remainder.Right( unconverted ) );
            buffer->InsertL( buffer->Size(), utfBuffer );
            finish = (unconverted == 0);
            }
        else
            {
            User::Leave( unconverted );
            }
        }

    buffer->Compress();
    ret = buffer->Ptr( 0 ).Alloc();
    CleanupStack::PopAndDestroy( buffer );
    CleanupStack::PushL( ret );
    return ret;
    }



// end of file