/*

* 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:  Launch Image Print App when file is marked or open MG

*

*/

#include "caiwprintingprovider.h"

#include <AiwMenu.h>

#include <AiwCommon.h>

#include <AiwCommon.hrh>

#include <coemain.h>

#include <barsread.h>

#include <imageprintuiprovider.rsg>

#include <e32property.h>

#include <s32strm.h>

#include <s32file.h>

#include <f32file.h>

#include <apacmdln.h>

#include <apgtask.h>

#include <apaid.h>

#include <apgcli.h>

#include <w32std.h>

#include <imageconversion.h>

#include <aknViewAppUi.h>

#include <aknnotedialog.h>

#include <aknstaticnotedialog.h>

#include <eikprogi.h>

#include <aknnotewrappers.h>

#include <StringLoader.h>

#include <pathinfo.h> 

#include "caiwimageprintif.h"

#include "imageprintuidebug.h"

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

// 

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

//

CAiwPrintingProvider* CAiwPrintingProvider::NewL()

    {

    CAiwPrintingProvider* self = new( ELeave ) CAiwPrintingProvider;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CAiwPrintingProvider::~CAiwPrintingProvider()

    {

    }

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

// 

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

//

void CAiwPrintingProvider::InitialiseL( MAiwNotifyCallback& aFrameworkCallback,

                                       const RCriteriaArray& /*aInterest*/ )

    {

    iNotifyCallback = &aFrameworkCallback;

    }

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

// 

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

//

void CAiwPrintingProvider::HandleServiceCmdL( const TInt& aCmdId,

                               const CAiwGenericParamList& aInParamList,

                               CAiwGenericParamList& aOutParamList,

                               TUint aCmdOptions,

                               const MAiwNotifyCallback* aCallback )

    {

    FLOG(_L("[CAiwPrintingProvider]<<<  HandleServiceCmdL BEGIN"));

    DoHandleCmdL( aCmdId, aInParamList, aOutParamList, aCmdOptions, aCallback );

    FLOG(_L("[CAiwPrintingProvider]<<<  HandleServiceCmdL END"));

    }

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

// 

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

//

void CAiwPrintingProvider::InitializeMenuPaneL

        ( CAiwMenuPane& aMenuPane, TInt aIndex,

         TInt /*aCascadeId*/, const CAiwGenericParamList& aInParamList )

    {

    FLOG(_L("[CAiwPrintingProvider]<<<  InitializeMenuPaneL BEGIN"));

    if ( IsPrintingSupported( aInParamList ) )

        {

        TResourceReader reader;

        iEikEnv.CreateResourceReaderLC

                ( reader, R_AIW_PRINTING_PROVIDER_MENU );

        aMenuPane.AddMenuItemsL( reader, KAiwCmdPrint, aIndex );

        CleanupStack::PopAndDestroy(); // aResourceId 

        }

    }

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

// 

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

//

void CAiwPrintingProvider::HandleMenuCmdL

        ( TInt aMenuCmdId, const CAiwGenericParamList& aInParamList,

         CAiwGenericParamList& aOutParamList, TUint aCmdOptions,

         const MAiwNotifyCallback* aCallback)

    {

    FLOG(_L("[CAiwPrintingProvider]<<<  HandleMenuCmdL BEGIN"));

    DoHandleCmdL( aMenuCmdId, aInParamList, aOutParamList, aCmdOptions, aCallback );

    FLOG(_L("[CAiwPrintingProvider]<<<  HandleMenuCmdL END"));

    }

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

// 

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

//

void CAiwPrintingProvider::DoHandleCmdL(TInt aMenuCmdId,

                            const CAiwGenericParamList& aInParamList,

                            CAiwGenericParamList& aOutParamList,

                            TUint /*aCmdOptions*/,

                            const MAiwNotifyCallback* aCallback)

    {

    if ( aMenuCmdId == KAiwCmdPrint || aMenuCmdId == KAiwCmdPrintPreview  )

        {

        FLOG(_L("[CAiwPrintingProvider]<<<  DoHandleCmdL"));

        CAiwGenericParamList* checkedParams = CAiwGenericParamList::NewL();

        iConsumerInParamList = &aInParamList;

        iConsumerOutParamList = &aOutParamList;

        iConsumerCallback = aCallback;

        TInt index( 0 );

	    const TAiwGenericParam* param = aInParamList.FindFirst(index,

	            EGenericParamFile,

	            EVariantTypeDesC);

	    while ( index != KErrNotFound )

			{

	        TFileName filename( param->Value().AsDes() );

 	        TInt err = KErrNone;

	        TBool result = EFalse;

	        TRAP( err, result = IsPrintingSupportedL( filename ) );

	        if ( err == KErrNone && result )

	        	{

	            FLOG(_L("[CAiwPrintingProvider] DoHandleCmdL; supported file"));

	        	checkedParams->AppendL(*param);

	        	}

	        else

	        	{

	        	FLOG(_L("[CAiwPrintingProvider] DoHandleCmdL; not supported"));

	        	++iNumberOfUnSuppFiles;

	        	iUnsupportedFiles = ETrue;

	        	}	

	        param = aInParamList.FindNext(index,

	            EGenericParamFile,

	            EVariantTypeDesC);

	        }

		FTRACE(FPrint(_L("[CAiwPrintingProvider] UnSuppFiles is %d"), iNumberOfUnSuppFiles )); 

		RFileWriteStream stream;

	  	CleanupClosePushL(stream);

		if((stream.Replace(iEikEnv.FsSession(), *iUnsuppFileName ,EFileWrite)) == KErrNone)

			{

			stream.WriteInt16L(iNumberOfUnSuppFiles);

			stream.CommitL();

			}

		CleanupStack::PopAndDestroy(&stream); 

        FLOG(_L("[IMAGEPRINTUI]<<< CAiwPrintingProvider;Save iUnsupportedFiles  is done"));

        RFileWriteStream writeStream;

        User::LeaveIfError( writeStream.Replace(iEikEnv.FsSession(),

        										*iPrintFileName , EFileWrite) );

        writeStream.PushL();

        checkedParams->ExternalizeL(writeStream);

        writeStream.CommitL();

        CleanupStack::PopAndDestroy( &writeStream );

        iNumberOfUnSuppFiles = 0;

        delete checkedParams;

        checkedParams = NULL;

        LaunchImagePrintApplicationL();

        FLOG(_L("[CAiwPrintingProvider]>>> DoHandleCmdL "));

        }

    }

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

// 

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

//

void CAiwPrintingProvider::StartApplicationL()

	{

	FLOG(_L("[CAiwPrintingProvider] StartApplicationL"));

	LaunchImagePrintApplicationL();

	}

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

// 

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

//

TBool CAiwPrintingProvider::IsImagePrintUiRunning()

    {

    TFindThread findt(KImagePrintUiSearchPatternBySID);

    TFullName result;

    TBool running(EFalse);

    if (!findt.Next(result))

        {

        FTRACE(FPrint(_L("[CAiwPrintingProvider] Thread '%S'is found"), &result));

        running = ETrue;

        }

     return running;

    }

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

// 

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

//

void CAiwPrintingProvider::ShowNoteL()

    {

    FLOG(_L("[CAiwPrintingProvider]>>> App launch error "));

    HBufC* str = StringLoader::LoadLC( R_USB_INFO_APP_IN_USE  );

    CAknErrorNote* note = new ( ELeave ) CAknErrorNote;

    note->ExecuteLD( *str );

    CleanupStack::PopAndDestroy( str );  // str	

    }

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

// 

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

//

void CAiwPrintingProvider::LaunchImagePrintApplicationL()

    {

    FLOG(_L("[CAiwPrintingProvider]<<< LaunchImagePrintApplicationL"));

    TUid appuid;

    appuid.iUid = KImagePrintUID;

    if (!IsImagePrintUiRunning())

        { 

        TRAPD( err, iService = CAknLaunchAppService::NewL(

        appuid,

        this,

        NULL ));

	    if ( err != KErrNone )

		   { 

		   FTRACE(FPrint(_L("[CAiwPrintingProvider] error when launch is  %d"), err ));

	       FLOG(_L("[CAiwPrintingProvider] LaunchImagePrintApplicationL  error"));

		   }   

        }

    else

        {

     	ShowNoteL(); 

		}

    FLOG(_L("[CAiwPrintingProvider]>>> LaunchImagePrintApplicationL"));

    }

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

// 

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

//

void CAiwPrintingProvider::HandleServerAppExit( TInt aReason )

    {

    delete iService;

    iService = NULL;

    FLOG(_L("[CAiwPrintingProvider]<<<  HandleServerAppExit"));

    // In the case that we want to exit also the parent application,

    // ImagePrint is exited with User::Exit() which is seen here as

    // KErrServerTerminated (-15).

    if( iConsumerInParamList && iConsumerOutParamList && iConsumerCallback && iConsumerCallback )

        {

        // Const cast is used to fix weirdness in AIW header files. MWaiNotifyCallback

        // does not define any const function but CAiwServiceIfMenu interface provides

        // const callback object.

        TRAP_IGNORE( const_cast<MAiwNotifyCallback*>(iConsumerCallback)->HandleNotifyL(

            KAiwCmdPrintPreview, KAiwEventCompleted,

            *iConsumerOutParamList, *iConsumerInParamList ));

        iConsumerInParamList = NULL;

        iConsumerOutParamList = NULL;

        iConsumerCallback = NULL;

        }

    if ( aReason == KErrServerTerminated )

        {

        FLOG(_L("[CAiwPrintingProvider]  HandleServerAppExit KErrServerTerminated"));

        }

    }

// End of file