/*

* Copyright (c) 2007 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:  Location Centre API interface.

*

*/

// SYSTEM INCLUDES

#include <s32mem.h>

#include <gulicon.h>

#include <aknlists.h>

#include <aknPopup.h>

#include <avkon.rsg>

// USER INCLUDES

#include "lcserviceimpl.h"

#include "lclocationappfilter.h"

#include "lcappexitobserver.h"

#include "lcnotification.h"

#include "lcapplauncher.h"

#include "lcipcparams.h"

#include "lcnotificationao.h"

#include "lciconloader.h"

#include "lcsyncoperation.h"

#include "lcpopuplistbox.h"

#include "lcdebug.h"

// ----- Member funtions for CLcServiceImpl ---------------------------------

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

// CLcServiceImpl::CLcServiceImpl

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

//

CLcServiceImpl::CLcServiceImpl()

    {

    // C++ Default constructor. No allocations or functions which can Leave

    // should be called from here.

    }

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

// CLcServiceImpl::~CLcServiceImpl

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

//

CLcServiceImpl::~CLcServiceImpl()

    {

    // C++ Destructor. Free all resources associated with this class.

    if ( iPopUp )

        {

        iPopUp->CancelPopup();

        }

    // Delele the Pop-up list    

    delete iPopUpListBox;

    // Delete the Selected ID buffer   

    delete iSelectedAppId;

    // Delete filter parameters

    delete iFilter;

    // Delete the Application information array

    iAppArray.Reset();

    iAppArray.Close();

    // Delete the Notification Active object

    delete iNotificationAO;

    // Delete the Application launcher

    delete iAppLauncher;

    // If there is an outstanding request then complete the same with KErrCancel.

    if ( iAsyncOperation )

    	{

    	iAsyncOperation->CancelGetLocationApplications();

    	User::RequestComplete( iStatus, KErrCompletion );

    	// We can now delete the asynchronous operation

    	delete iAsyncOperation;

    	iAsyncOperation = NULL;

    	} 

    // Close the session handle. The session handle is active throughout the

    // lifetime of this class

    iSession.Close();

    }

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

// CLcServiceImpl* CLcServiceImpl::NewL

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

//

CLcServiceImpl* CLcServiceImpl::NewL()

    {

    CLcServiceImpl* self = NewLC();

    CleanupStack::Pop( self );

    return self;         

    }

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

// CLcServiceImpl* CLcServiceImpl::NewLC

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

//

CLcServiceImpl* CLcServiceImpl::NewLC()

    {

    // Symbian Two phased constructor. Leaves the object on the Clean-up

    // stack.

    CLcServiceImpl* self = 

                new ( ELeave )CLcServiceImpl();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;         

    }

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

// void CLcServiceImpl::ConstructL

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

//

void CLcServiceImpl::ConstructL()

    {

    // Second phase of the two phase constructor.

    // Open a connection to the Location Centre Server

    // The connection is opened at the class construction and Closed at the

    // class deletion. This is done inorder to avoid delays during every

    // operation

    User::LeaveIfError( iSession.CreateSession());

    // Create the Location application launcher.

    iAppLauncher = CLcAppLauncher::NewL();

    // Create the Notification AO

    iNotificationAO = CLcNotificationAO::NewL( *this, iSession );

    }

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

// void CLcServiceImpl::LaunchLocationCentreL

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

//

void CLcServiceImpl::LaunchLocationCentreL( 

              const TLcLocationAppFilter&             aLocationAppFilter,

                    CLcLocationAppInfo::TLcLaunchMode aLaunchMode,                        

                    MLcAppExitObserver*               aChainedAppExitObserver )

    {

    DEBUG("+ CLcServiceImpl::LaunchLocationCentreL")

    // First select a Location based Application from the list

    TPtrC identifier = SelectLocationApplicationL( aLocationAppFilter );

    if ( !identifier.Length())

        {

        return;

        }    

    // Launch the corresponding application.

    LaunchLocationApplicationL( identifier, aLaunchMode, aChainedAppExitObserver );

    DEBUG("- CLcServiceImpl::LaunchLocationCentreL")

    }

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

// void CLcServiceImpl::LaunchLocationCentreL

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

//

void CLcServiceImpl::LaunchLocationCentreL(

      const RPointerArray<CLcService::CLcLaunchParam>& aIncludeAppArray,

      MLcAppExitObserver*                              aChainedAppExitObserver )

    {

    // Form an array of applications identifiers which can be passed to the

    // selection function

    RArray<TPtrC>  appArray;

    CleanupClosePushL( appArray );

    TInt count = aIncludeAppArray.Count();    

    for( TInt i = 0; i < count; i++ )

        {

        User::LeaveIfError( appArray.Append( aIncludeAppArray[i]->Id()));

        }

    // First select a Location based Application from the list

    TPtrC identifier = SelectLocationApplicationL( appArray, ETrue );    

    if ( !identifier.Length())

        {

        return;

        }

    CLcLocationAppInfo::TLcLaunchMode launchmode = CLcLocationAppInfo::EDefaultMode;

    // Obtain the launch mode for that application            

    for ( TInt i = 0; i < count; i++ )

        {

        if ( !appArray[i].Compare( identifier ))

            {

            launchmode = aIncludeAppArray[i]->LaunchMode();

            break;

            }

        }

    // Launch the corresponding application.

    LaunchLocationApplicationL( identifier, launchmode, aChainedAppExitObserver ); 

    // Pop and Destroy the application array        

    CleanupStack::PopAndDestroy();

    }

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

// void CLcServiceImpl::LaunchLocationCentreL

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

//

void CLcServiceImpl::LaunchLocationCentreL( 

                    const RArray<TPtrC>&              aExcludeAppArray,

                    CLcLocationAppInfo::TLcLaunchMode aLaunchMode,

                    MLcAppExitObserver*               aChainedAppExitObserver )

    {

    // First select a Location based Application from the list

    TPtrC identifier = SelectLocationApplicationL( aExcludeAppArray, EFalse );

    if ( !identifier.Length())

        {

        return;

        }    

    // Launch the corresponding application.

    LaunchLocationApplicationL( identifier, aLaunchMode, aChainedAppExitObserver );    

    }

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

// void CLcServiceImpl::SelectLocationApplicationL

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

//

TPtrC CLcServiceImpl::SelectLocationApplicationL(

                        const TLcLocationAppFilter&     aLocationAppFilter )

    {

    // If the pop-up dialog is currently being displayed then cannot proceed with

    // the request.

    if ( iPopUp )

        {

        User::Leave( KErrInUse );

        }

    iPopupOutStanding = ELcPopupWithFiltering;

    // Delete any existing filter. This condition should never occur. Just a safe

    // check.

    delete iFilter;

    iFilter = NULL;

    // Copy the filter contents

    iFilter = new ( ELeave ) TLcLocationAppFilter( aLocationAppFilter );

    // Obtain the list of applications from the Location Centre Server and

    // launch the Location Centre pop-up with that list.    

    CLcLocationAppInfoArray* array = GetLocationApplicationsL( aLocationAppFilter );

    // The ownership of the array is transferred.

    TPtrC  appId(KNullDesC());

    TRAPD( error, appId.Set( SelectLocationApplicationL( array )));

    // Delete the filter before any operation on the result        

    delete iFilter;

    iFilter = NULL;

    // Handle Error 

    if ( error )

        {

        if ( iPopUp )

            {

            iPopUp->CancelPopup();            

            }

        iPopUp = NULL;

        delete iPopUpListBox;

        iPopUpListBox = NULL;

        User::Leave( error );        

        }        

    return appId;        

    }

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

// void CLcServiceImpl::SelectLocationApplicationL

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

//

TPtrC CLcServiceImpl::SelectLocationApplicationL(

                            const RArray<TPtrC>&      aAppArray,

                                  TBool               aIncludeFlag )

    {

    // If the pop-up dialog is currently being displayed then cannot proceed with

    // the request.

    if ( iPopUp )

        {

        User::Leave( KErrInUse );

        }

    // Reset and Destroy the existing array.

    iAppArray.Reset();

    if ( aIncludeFlag )

        {

        iPopupOutStanding = ELcPopupWithSpecifiedApps;

        }

    else

        {

        iPopupOutStanding = ELcPopupWithoutSpecifedApps;

        }

    // Create the array with the new elements

    TInt count = aAppArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        User::LeaveIfError( iAppArray.Append( aAppArray[i] ));

        }

    // Obtain the list of applications from the Location Centre Server and

    // launch the Location Centre pop-up with that list.    

    CLcLocationAppInfoArray* array = 

                    LcSyncOperation::GetLocationApplicationsL( iSession,

                                                               aAppArray,

                                                               aIncludeFlag );

    // The ownership of the array is transferred.

    TPtrC  appId(KNullDesC());

    TRAPD( error, appId.Set( SelectLocationApplicationL( array )));

    // Reset and destroy the array

    iAppArray.Reset();

    // Handle Error    

    if ( error )

        {

        if ( iPopUp )

            {

            iPopUp->CancelPopup();            

            }

        iPopUp = NULL;

        delete iPopUpListBox;

        iPopUpListBox = NULL;

        User::Leave( error );

        }

    return appId;         

    }

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

// CLcLocationAppInfoArray* CLcServiceImpl::GetLocationApplicationsL

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

//    

CLcLocationAppInfoArray* CLcServiceImpl::GetLocationApplicationsL(

            const TLcLocationAppFilter&         aLocationAppFilter )

    {

    return LcSyncOperation::GetLocationApplicationsL( iSession,

    												  aLocationAppFilter );

    }

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

// void CLcServiceImpl::GetLocationApplicationsL

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

//    

void CLcServiceImpl::GetLocationApplications(

                            TRequestStatus&             aStatus,

                      const TLcLocationAppFilter&       aLocationAppFilter,                            

                            CLcLocationAppInfoArray*&   aAppInfoArray)

    {

    TRAPD( error, GetLocationApplicationsL( aStatus,

    										aLocationAppFilter,

    										aAppInfoArray ));

	if ( error )

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete( status , error );

		}

    }

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

// void CLcServiceImpl::CancelGetLocationApplications

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

//     

void CLcServiceImpl::CancelGetLocationApplications()

    {

    // If there is an outstanding request then complete the same with KErrCancel.

    if ( iAsyncOperation )

    	{

    	iAsyncOperation->CancelGetLocationApplications();

    	User::RequestComplete( iStatus, KErrCancel );

    	// We can now delete the asynchronous operation

    	delete iAsyncOperation;

    	iAsyncOperation = NULL;

    	} 

    }

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

// void CLcServiceImpl::LaunchLocationApplicationL

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

// 

void CLcServiceImpl::LaunchLocationApplicationL( 

                const TDesC&                      aAppIdentifier,

                CLcLocationAppInfo::TLcLaunchMode aLaunchMode,

                MLcAppExitObserver*               aChainedAppExitObserver )

    {

    DEBUG("+ CLcServiceImpl::LaunchLocationApplicationL" )

    // Obtain the Location Application Information from Location Centre Server.

    CLcBasicAppInfo* appInfo = 

    	LcSyncOperation::GetLocationAppInfoL( iSession, aAppIdentifier );

    CleanupStack::PushL( appInfo );

    // Resolve the model in which the Application must be launched.

    if ( aLaunchMode == CLcLocationAppInfo::EDefaultMode )

    	{

    	// Since this is a Local copy we can use the same for handling

    	// Launch mode changes.

    	aLaunchMode = 

    		static_cast<CLcLocationAppInfo::TLcLaunchMode>( appInfo->LaunchMode());

    	}

	// Now Launch the Location based Application or Content/Service    	

    iAppLauncher->LaunchLocationApplicationL( 

			appInfo->ApplicationType(),

            appInfo->ApplicationData(),

            ( aLaunchMode == CLcLocationAppInfo::EStandAloneMode ) ? ETrue : EFalse,

            appInfo->CommandLineParamters(),

            aChainedAppExitObserver );

	CleanupStack::PopAndDestroy( appInfo );                                          

	DEBUG("- CLcServiceImpl::LaunchLocationApplicationL" )                                          

    }

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

// void CLcServiceImpl::SetObserverL

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

// 

void CLcServiceImpl::SetObserverL( MLcNotification&     aObserver )

    {

    if ( iObserver )

        {

        User::Leave( KErrAlreadyExists );

        }

    iObserver = &aObserver;

    iNotificationAO->IssueRequest();

    }

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

// TInt CLcServiceImpl::RemoveObserver

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

//                                         

TInt CLcServiceImpl::RemoveObserver()

    {

    if ( !iObserver )

        {

        return KErrNotFound;

        }

    iObserver = NULL;

    // If there is a popup outstanding then do nothing. If not remove the

    // notification

    if ( !iPopUp )

        {

        iNotificationAO->CancelRequest();        

        }

    return KErrNone;

    }

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

// void CLcServiceImpl::LcStatusChangedL

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

// 

void CLcServiceImpl::LcStatusChangedL( TInt aErrorCode )

    {

    // If we are displaying the pop-up then we need to transfer the changes

    // to the pop-up first

    if ( iPopUp )

        {

        // Obtain the new list of applications from the Location Centre Server and

        // update the Location Centre pop-up with that list.    

        CLcLocationAppInfoArray* array = NULL;

        TInt error = KErrNone;

        switch( iPopupOutStanding )

            {

            case ELcPopupWithFiltering:

                {                

                // Incase we face any errors in retrival then we can Ignore the

                // updations

                TRAP( error, array = GetLocationApplicationsL( *iFilter ));

                break;

                }

            case ELcPopupWithSpecifiedApps:

            case ELcPopupWithoutSpecifedApps:            

                {

                TBool includeflag = EFalse;

                if ( iPopupOutStanding == ELcPopupWithSpecifiedApps )

                    {

                    includeflag = ETrue;

                    }

                // Incase we face any errors in retrival then we can Ignore the

                // updations

                TRAP( error, array = LcSyncOperation::GetLocationApplicationsL( 

                                                        iSession, iAppArray, includeflag ));

                break;

                }

            default:

                {

                break;

                }

            }

        if ( !error && array )

            {

            // The ownership of the array is transferred to the list box.

            TRAP_IGNORE( CleanupStack::PushL( array ); 

                         iPopUpListBox->UpdateListBoxL( array );

                         CleanupStack::Pop( array );

                       );

            }