/*

* Copyright (c) 2008 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:  Context publishing helper dll

*

*/

#include <cfcontextobject.h>

#include <cfclient.h>

#include <mdesession.h>

#include <mdeobject.h>

#include <s32mem.h>

#include <MVPbkContactLink.h>

#include <MVPbkStoreContact.h>

#include <MVPbkStreamable.h>

#include <CVPbkContactLinkArray.h>

#include <e32debug.h>

#include <w32std.h>

#include "hgcontextutilityimpl.h"

#include "hgcontexttypes.h"

// max number of entries processed when aContextData is an array in PublishContextL

const TInt KMaxEntriesInMulti = 20;

// separator character in combined string for multiple entries

const TInt KMultiSepChar = 0x0001;

// granularity for string array

const TInt KArrayGranularity = 4;

// argument for CBufFlat ctor when serializing contact links

const TInt KBufGranularity = 64;

// default security policy (use LocalServices cap) for contexts

_LIT_SECURITY_POLICY_C1( KContextSecurity, ECapabilityLocalServices );

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

// CHgContextUtilityImpl::NewL

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

//

CHgContextUtilityImpl* CHgContextUtilityImpl::NewL()

    {

    CHgContextUtilityImpl* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CHgContextUtilityImpl::NewLC

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

//

CHgContextUtilityImpl* CHgContextUtilityImpl::NewLC()

    {

    CHgContextUtilityImpl* self = new ( ELeave ) CHgContextUtilityImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CHgContextUtilityImpl::CHgContextUtilityImpl

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

//

CHgContextUtilityImpl::CHgContextUtilityImpl()

        : CTimer( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CHgContextUtilityImpl::ConstructL

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

//

void CHgContextUtilityImpl::ConstructL()

    {

    CTimer::ConstructL();

    iEnv = CCoeEnv::Static(); // may be NULL

    // Do not create iCFClient here as cf server may not be available yet

    // if we are early in the boot phase.

    // set defaults

    RePublishWhenFgL( EFalse );

    AllowPublishFromBackground( EFalse );

    }

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

// CHgContextUtilityImpl::~CHgContextUtilityImpl

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

//

CHgContextUtilityImpl::~CHgContextUtilityImpl()

    {

    Cancel();

    delete iPendingContextType;

    delete iPendingContextData;

    delete iPendingContextDataArray;

    delete iCFClient;

    delete iLastContextType;

    delete iLastContextData;

    if ( iFgWatchEnabled && iEnv )

        {

        iEnv->RemoveForegroundObserver( *this );

        }

    iMusicContextInfo.ResetAndDestroy();

    }

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

// CHgContextUtilityImpl::CFReady

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

//

TBool CHgContextUtilityImpl::CFReady()

    {

    if ( !iCFClient )

        {

        TRAPD( err, iCFClient = CCFClient::NewL( *this ) );

        if ( err != KErrNone )

            {

            RDebug::Printf( "[hgctxutil] cfw not ready" );

            return EFalse;

            }

        }

    return ETrue;

    }

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

// CHgContextUtilityImpl::PublishContextL

// All other non-static versions of this function will fall back to this one.

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

//

void CHgContextUtilityImpl::PublishContextL( const TDesC& aContextType,

        const TDesC& aContextData )

    {

    RDebug::Print( _L("[hgctxutil] PublishContextL [%S] [%S]"),

        &aContextType, &aContextData );

    // create cf client instance if not yet done

    // and check foreground status if needed

    if ( CFReady() && AllowedToPublish() )

        {

        // call static version with our cf client instance

        PublishContextL( *iCFClient, aContextType, aContextData );

        }

    // store type and value for later use

    // (even when cfserver is not available yet, the data may still be

    //  used later when the app comes to foreground, for example)

    if ( iLastContextType != &aContextType )

        {

        delete iLastContextType; iLastContextType = 0;

        iLastContextType = aContextType.AllocL();

        }

    if ( iLastContextData != &aContextData )

        {

        delete iLastContextData; iLastContextData = 0;

        iLastContextData = aContextData.AllocL();

        }

    }

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

// AppendCharL

// Appends a char to aDst, calls ReAllocL when needed, assumes that aDst

// is also on cleanupstack (at top position) so it updates that pointer too.

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

//

LOCAL_C void AppendCharL( HBufC*& aDst, TChar aChar )

    {

    TPtr des( aDst->Des() );

    if ( des.Length() == des.MaxLength() )

        {

        HBufC* oldDst = aDst;

        aDst = aDst->ReAllocL( des.MaxLength() * 2 );

        CleanupStack::Pop( oldDst ); // pop the old pointer

        CleanupStack::PushL( aDst ); // and push the new (possibly different) one

        des.Set( aDst->Des() );

        }

    des.Append( aChar );

    }

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

// CHgContextUtilityImpl::BuildCombinedStringL

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

//

HBufC* CHgContextUtilityImpl::BuildCombinedStringL(

        const MDesCArray& aArray )

    {

    TInt arrayCount = aArray.MdcaCount();

    if ( arrayCount >= 2 )

        {

        // Rules:

        // 1. escape all separator chars in the input with a preceeding \

        // 2. escape all \ chars in the input with \\

        // 3. take only the first KMaxEntriesInMulti elements from the array

        // 4. append a separator also after last entry

        // 5. prepend two separators to the combined string

        TInt processedEntryCount = Min( arrayCount, KMaxEntriesInMulti );

        // calculate a big enough size so we can avoid ReAllocL calls later

        TInt sz = 0;

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

            {

            sz += aArray.MdcaPoint( i ).Length() + 1;

            }

        sz += 2; // for the magic prefix

        HBufC* value = HBufC::NewLC( sz );

        AppendCharL( value, KMultiSepChar );

        AppendCharL( value, KMultiSepChar );

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

            {

            TPtrC entry( aArray.MdcaPoint( i ) );

            // append, also do the escaping

            for ( TInt j = 0, je = entry.Length(); j != je; ++j )

                {

                TChar c = entry[j];

                if ( c == KMultiSepChar || c == '\\' )

                    {

                    AppendCharL( value, '\\' );

                    }

                AppendCharL( value, c );

                }

            AppendCharL( value, KMultiSepChar );

            }

        CleanupStack::Pop( value );

        return value;

        }

    return 0;

    }

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

// CHgContextUtilityImpl::SplitCombinedStringL

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

//

void CHgContextUtilityImpl::SplitCombinedStringL(

        const TDesC& aString, CDesCArray& aArray )

    {

    TInt inputLength = aString.Length();

    TBool isMulti = inputLength > 2

        && aString[0] == KMultiSepChar && aString[1] == KMultiSepChar;

    if ( isMulti )

        {

        // allocate a work buffer that is big enough for sure

        HBufC* buf = HBufC::NewLC( inputLength );

        TPtr des( buf->Des() );

        TBool esc = EFalse;

        // go through the string, find entries, and add them to output array

        for ( TInt i = 2; i < inputLength; ++i ) // start from 2 because of the magic prefix

            {

            TChar c = aString[i];

            if ( c == '\\' && !esc )

                {

                esc = ETrue;

                }

            else if ( c == KMultiSepChar && !esc )

                {

                // found separator: append to output array, clear buffer, and continue

                aArray.AppendL( des );

                des.Zero();

                }

            else

                {

                esc = EFalse;

                des.Append( c );

                }

            }

        CleanupStack::PopAndDestroy( buf );

        }

    else

        {

        // not a combined string: append to array as it is

        aArray.AppendL( aString );

        }

    }

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

// CHgContextUtilityImpl::PublishContextL

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

//

void CHgContextUtilityImpl::PublishContextL( const TDesC& aContextType,

        const MDesCArray& aContextData )

    {

    TInt entryCount = aContextData.MdcaCount();

    // do nothing if array is empty

    if ( !entryCount )

        {

        return;

        }

    // nothing special when having only 1 item

    if ( entryCount == 1 )

        {

        PublishContextL( aContextType, aContextData.MdcaPoint( 0 ) );

        return;

        }

    // at least two items: create the special combined string

    HBufC* value = BuildCombinedStringL( aContextData );

    CleanupStack::PushL( value );

    // publish the combined string

    PublishContextL( aContextType, *value );

    CleanupStack::PopAndDestroy( value );

    }

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

// CHgContextUtilityImpl::PublishContextL

// This is the version of the function where the real work is performed.

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

//

void CHgContextUtilityImpl::PublishContextL( CCFClient& aCFClient,

        const TDesC& aContextType, const TDesC& aContextData )

    {

    CCFContextObject* context = CCFContextObject::NewLC();

    context->SetSourceL( KHgCFSource );

    context->SetTypeL( aContextType );

    context->SetValueL( aContextData );

    TInt err = aCFClient.PublishContext( *context );

    if ( err == KErrNotFound )

        {

        User::LeaveIfError( aCFClient.DefineContext( KHgCFSource,

            aContextType, KContextSecurity ) );

        err = aCFClient.PublishContext( *context );

        if ( err != KErrArgument ) // ignore -6 which comes e.g. when trying to publish an empty value

            {

            User::LeaveIfError( err );

            }

        }

    else if ( err != KErrArgument )

        {

        User::LeaveIfError( err );

        }

    CleanupStack::PopAndDestroy( context );

    }

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

// CHgContextUtilityImpl::GetContextL

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

//

HBufC* CHgContextUtilityImpl::GetContextL( const TDesC& aContextSource,

        const TDesC& aContextType )

    {

    HBufC* ret = 0;

    if ( CFReady() )

        {

        CCFContextQuery* query = CCFContextQuery::NewLC();

        query->SetSourceL( aContextSource );

        query->SetTypeL( aContextType );

        RContextObjectArray result;

        TInt err = iCFClient->RequestContext( *query, result );

        if ( err == KErrNone && result.Count() )

            {

            ret = result[0]->Value().Alloc();

            }

        result.ResetAndDestroy();

        CleanupStack::PopAndDestroy( query );

        }

    return ret;

    }

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

// CHgContextUtilityImpl::GetContextL

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

//

HBufC* CHgContextUtilityImpl::GetContextL( const TDesC& aContextType )

    {

    return GetContextL( KHgCFSource, aContextType );

    }

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

// CHgContextUtilityImpl::PublishContextDelayedL

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

//

void CHgContextUtilityImpl::PublishContextDelayedL( const TDesC& aContextType,

        const TDesC& aContextData, TTimeIntervalMicroSeconds32 aDelay )

    {

    Cancel();

    delete iPendingContextType; iPendingContextType = 0;

    iPendingContextType = aContextType.AllocL();

    delete iPendingContextData; iPendingContextData = 0;

    iPendingContextData = aContextData.AllocL();

    delete iPendingContextDataArray; iPendingContextDataArray = 0;

    After( aDelay );

    }

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

// CHgContextUtilityImpl::PublishContextDelayedL

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

//

void CHgContextUtilityImpl::PublishContextDelayedL( const TDesC& aContextType,

        const MDesCArray& aContextData, TTimeIntervalMicroSeconds32 aDelay )

    {

    Cancel();

    delete iPendingContextType; iPendingContextType = 0;

    iPendingContextType = aContextType.AllocL();

    delete iPendingContextData; iPendingContextData = 0;

    if ( iPendingContextDataArray )

        {

        iPendingContextDataArray->Reset();

        }

    else

        {

        iPendingContextDataArray = new ( ELeave ) CDesC16ArrayFlat( KArrayGranularity );

        }

    for ( TInt i = 0, ie = aContextData.MdcaCount(); i != ie; ++i )

        {

        iPendingContextDataArray->AppendL( aContextData.MdcaPoint( i ) );

        }

    After( aDelay );

    }

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

// CHgContextUtilityImpl::RunL

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

//

void CHgContextUtilityImpl::RunL()

    {

    if ( iPendingContextType )

        {

        if ( iPendingContextData )

            {

            PublishContextL( *iPendingContextType, *iPendingContextData );

            }

        else if ( iPendingContextDataArray )

            {

            PublishContextL( *iPendingContextType, *iPendingContextDataArray );

            }

        }

    }

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

// CHgContextUtilityImpl::RunError

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

//

TInt CHgContextUtilityImpl::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

// empty implementations for cfw

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

// CHgContextUtilityImpl::ContextIndicationL

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

//

void CHgContextUtilityImpl::ContextIndicationL(

		const CCFContextIndication& /*aChangedContext*/ )

	{

	// empty

	}

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

// CHgContextUtilityImpl::ActionIndicationL

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

//

void CHgContextUtilityImpl::ActionIndicationL(

		const CCFActionIndication& /*aActionToExecute*/ )

	{

	// empty

	}

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

// CHgContextUtilityImpl::HandleContextFrameworkError

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

//

void CHgContextUtilityImpl::HandleContextFrameworkError( TCFError /*aError*/,

	    const TDesC& /*aSource*/,

	    const TDesC& /*aType*/ )

	{

	// empty

	}

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

// CHgContextUtilityImpl::Extension

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

//

TAny* CHgContextUtilityImpl::Extension( const TUid& /*aExtensionUid*/ ) const

	{

	return 0;

	}

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

// CHgContextUtilityImpl::MakeLinkPublishableLC

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

//

HBufC* CHgContextUtilityImpl::MakeLinkPublishableLC(

        const MVPbkContactLink& aLink )

    {

    HBufC* ret = 0;

    // serialize the link and place it into a 16-bit descriptor

    // prefixed with one special mark character

    const MVPbkStreamable* strm = aLink.Streamable();

    User::LeaveIfNull(strm);

    CBufFlat* buf = CBufFlat::NewL( KBufGranularity );

    CleanupStack::PushL( buf );

    RBufWriteStream ws;

    CleanupClosePushL( ws );

    ws.Open( *buf );

    strm->ExternalizeL( ws );

    CleanupStack::PopAndDestroy( &ws );

    TPtr8 p( buf->Ptr( 0 ) );

    ret = HBufC::NewLC( p.Length() + 1 );

    TPtr des( ret->Des() );

    des.Copy( p );

    _LIT( KTemp, " " );

    des.Insert( 0, KTemp );

    des[0] = KHgCFValueLinkMarker; // codescanner::accessArrayElementWithoutCheck2

    CleanupStack::Pop( ret );

    CleanupStack::PopAndDestroy( buf );

    CleanupStack::PushL( ret );

    return ret;

    }

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

// CHgContextUtilityImpl::PublishContactContextL

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

//

void CHgContextUtilityImpl::PublishContactContextL(

        const MVPbkStoreContact& aContact,

        const TTimeIntervalMicroSeconds32& aDelay )

    {

    MVPbkContactLink* link = aContact.CreateLinkLC();

    if ( link )

        {

        HBufC* pubstr = MakeLinkPublishableLC( *link );