Added the setting file, which enables the automatic launch of the publisher. Fixed the issues with the .pkg files.
/*
* Copyright (c) {Year(s)} {Copyright owner}.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
*
* Initial Contributors:
* {Name} {Company} ? Initial contribution
*
* Contributors:
* {Name} {Company} ? {{Description of contribution}}
*
* Description:
* {{Description of the file}}
*
*/
// System includes
#include <liwservicehandler.h>
#include <liwvariant.h>
#include <liwgenericparam.h>
#include <fbs.h>
// User includes
#include "transaction.h"
#include "hswidgetobserver.h"
#include "hspublisherimpl.h"
// Constants
_LIT8( KCPSConfigurationIf, "IContentPublishing" );
_LIT8( KCPS, "Service.ContentPublishing" );
_LIT( KCpData, "cp_data" );
_LIT( KHsWidget, "hswidget" );
_LIT( KPublisher, "publisher" );
_LIT( KAll, "all" );
_LIT( KDataAndPublisher, "cp_data:publisher" );
_LIT8( KAdd, "add" );
_LIT8( KType, "type" );
_LIT8( KFilter, "filter" );
_LIT8( KFlag, "flag" );
_LIT8( KErrorCode, "ErrorCode" );
_LIT8( KDataMap, "data_map" );
_LIT8( KItem, "item" );
_LIT8( KDelete, "Delete" );
_LIT8( KPublisherId, "publisher" );
_LIT8( KContentType, "content_type" );
_LIT8( KContentId, "content_id" );
_LIT8( KOperation, "operation" );
_LIT8( KExecute, "execute" );
_LIT8( KRequestNotification, "RequestNotification" );
_LIT8( KChangeInfo, "change_info" );
_LIT8( KActionTrigger, "action_trigger" );
_LIT8( KActionMap, "action_map" );
_LIT8( KActive, "active" );
_LIT8( KSuspend, "suspend" );
_LIT8( KResume, "resume" );
_LIT8( KOnline, "online" );
_LIT8( KOffline, "offline" );
_LIT8( KSystemStartup, "systemstartup" );
_LIT8( KPageStartup, "pagestartup" );
_LIT8( KWidgetStartup, "pluginstartup" );
_LIT8( KSystemShutdown, "systemshutdown" );
_LIT8( KPageShutdown, "pageshutdown" );
_LIT8( KWidgetShutdown, "pluginshutdown" );
const TUint KDisablePersist( 0x1000 );
// Type definitions
typedef TBuf< 256 > TVariantBuf;
typedef TBuf8< 256 > TVariantBuf8;
// ============================= LOCAL FUNCTIONS ===============================
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHsPublisherImpl::NewLC()
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CHsPublisherImpl* CHsPublisherImpl::NewLC( MHsWidgetObserver& aObserver,
TBool aEnablePersist )
{
CHsPublisherImpl* self = new ( ELeave )
CHsPublisherImpl( aObserver, aEnablePersist );
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::NewL()
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CHsPublisherImpl* CHsPublisherImpl::NewL( MHsWidgetObserver& aObserver,
TBool aEnablePersist )
{
CHsPublisherImpl* self =
CHsPublisherImpl::NewLC( aObserver, aEnablePersist );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::CHsPublisherImpl()
// C++ default constructor
// -----------------------------------------------------------------------------
//
CHsPublisherImpl::CHsPublisherImpl( MHsWidgetObserver& aObserver,
TBool aEnablePersist )
: iObserver( aObserver ),
iEnablePersist( aEnablePersist )
{
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::ConstructL()
// 2nd phase constructor
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::ConstructL()
{
AttachL();
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::~CHsPublisherImpl()
// Destructor
// -----------------------------------------------------------------------------
//
CHsPublisherImpl::~CHsPublisherImpl()
{
iTransactions.ResetAndDestroy();
TRAP_IGNORE( DetachL() );
}
// ---------------------------------------------------------------------------
// CHsPublisherImpl::AttachL
//
// ---------------------------------------------------------------------------
//
void CHsPublisherImpl::AttachL()
{
// Attach to CPS service
RCriteriaArray interestList;
CleanupClosePushL( interestList );
iServiceHandler = CLiwServiceHandler::NewL();
iCpsService = CLiwCriteriaItem::NewL( 1, KCPSConfigurationIf, KCPS );
iCpsService->SetServiceClass( TUid::Uid( KLiwClassBase ) );
interestList.AppendL( iCpsService );
iServiceHandler->AttachL( interestList );
CLiwGenericParamList& inParamList( iServiceHandler->InParamListL() );
CLiwGenericParamList& outParamList( iServiceHandler->OutParamListL() );
iServiceHandler->ExecuteServiceCmdL(
*iCpsService,
inParamList,
outParamList );
TInt pos( 0 );
outParamList.FindFirst( pos, KCPSConfigurationIf );
if ( pos != KErrNotFound )
{
iCpsInterface = outParamList[pos].Value().AsInterface();
}
inParamList.Reset();
outParamList.Reset();
if ( !iCpsInterface )
{
User::Leave( KErrNotFound );
}
const TDesC& publisherId( iObserver.Identity() );
// Register Observer
CLiwDefaultMap* reqmap = CLiwDefaultMap::NewLC();
reqmap->InsertL( KPublisherId, TLiwVariant( publisherId ) );
reqmap->InsertL( KContentType, TLiwVariant( KAll ) );
reqmap->InsertL( KContentId, TLiwVariant( KAll ) );
reqmap->InsertL( KOperation, TLiwVariant( KExecute ) );
inParamList.AppendL( TLiwGenericParam(
KType, TLiwVariant( KDataAndPublisher ) ) );
inParamList.AppendL( TLiwGenericParam(
KFilter, TLiwVariant( reqmap ) ) );
iCpsInterface->ExecuteCmdL(
KRequestNotification, inParamList, outParamList, 0, this );
const TLiwGenericParam* outparam( NULL );
pos = 0;
outparam = outParamList.FindFirst( pos, KErrorCode );
TInt err( KErrNone );
if ( outparam )
{
if ( outparam->Value().AsTInt32() )
{
err = KErrGeneral;
}
}
inParamList.Reset();
outParamList.Reset();
User::LeaveIfError( err );
CleanupStack::PopAndDestroy( reqmap );
// Register Publisher
CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();
CLiwDefaultMap* actionmap = CLiwDefaultMap::NewLC();
datamap->InsertL( KPublisherId, TLiwVariant( publisherId ) );
datamap->InsertL( KContentType, TLiwVariant( KAll ) );
datamap->InsertL( KContentId, TLiwVariant( KAll ) );
actionmap->InsertL( KActive, TLiwVariant() );
datamap->InsertL( KActionMap, TLiwVariant( actionmap ) );
inParamList.AppendL( TLiwGenericParam(
KType, TLiwVariant( KPublisher ) ) );
inParamList.AppendL( TLiwGenericParam(
KItem, TLiwVariant( datamap ) ) );
iCpsInterface->ExecuteCmdL( KAdd, inParamList, outParamList );
outparam = NULL;
pos = 0;
outparam = outParamList.FindFirst( pos, KErrorCode );
err = KErrNone;
if ( outparam )
{
if ( outparam->Value().AsTInt32() )
{
err = KErrGeneral;
}
}
inParamList.Reset();
outParamList.Reset();
User::LeaveIfError( err );
CleanupStack::PopAndDestroy( 2, datamap ); // actionmap
CleanupStack::PopAndDestroy( &interestList );
iCpServiceAvailable = ETrue;
}
// ---------------------------------------------------------------------------
// CHsPublisherImpl::DetachL
//
// ---------------------------------------------------------------------------
//
void CHsPublisherImpl::DetachL()
{
if ( iServiceHandler && iCpsInterface )
{
CLiwGenericParamList& inParamList( iServiceHandler->InParamListL() );
CLiwGenericParamList& outParamList( iServiceHandler->OutParamListL() );
// Remove widget data
CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();
const TDesC& publisherId( iObserver.Identity() );
cpdatamap->InsertL( KPublisherId, TLiwVariant( publisherId ) );
cpdatamap->InsertL( KContentType, TLiwVariant( KAll ) );
cpdatamap->InsertL( KContentId, TLiwVariant( KAll ) );
inParamList.AppendL( TLiwGenericParam(
KType, TLiwVariant( KCpData ) ) );
inParamList.AppendL( TLiwGenericParam(
KItem, TLiwVariant( cpdatamap ) ) );
TRAP_IGNORE( iCpsInterface->ExecuteCmdL(
KDelete, inParamList, outParamList ) );
inParamList.Reset();
outParamList.Reset();
CleanupStack::PopAndDestroy( cpdatamap );
// Unregister Observer
TRAP_IGNORE( iCpsInterface->ExecuteCmdL(
KRequestNotification,
inParamList,
outParamList,
KLiwOptCancel,
this ) );
// Detach from CPS service
if ( iCpsInterface )
{
// Close interface
iCpsInterface->Close();
}
iCpsInterface = NULL;
if ( iServiceHandler && iCpsService )
{
// Detach services from the handler
RCriteriaArray list;
list.Append( iCpsService );
TRAP_IGNORE( iServiceHandler->DetachL( list ) );
list.Reset();
}
}
delete iCpsService;
iCpsService = NULL;
delete iServiceHandler;
iServiceHandler = NULL;
iCpServiceAvailable = EFalse;
}
// ---------------------------------------------------------------------------
// CHsPublisherImpl::HandleNotifyL
//
// ---------------------------------------------------------------------------
//
TInt CHsPublisherImpl::HandleNotifyL( TInt /*aCmdId*/, TInt /*aEventId*/,
CLiwGenericParamList& aEventParamList,
const CLiwGenericParamList& /*aInParamList*/ )
{
TInt pos( 0 );
aEventParamList.FindFirst( pos, KChangeInfo );
if ( pos == KErrNotFound )
{
return pos;
}
const TDesC& publisherId( iObserver.Identity() );
// Get list of maps
TLiwVariant listvariant( aEventParamList[pos].Value() );
listvariant.PushL();
const CLiwList* list( listvariant.AsList() );
// Iterate through list
for ( TInt i = 0; i < list->Count(); i++ )
{
TVariantBuf publisher;
TVariantBuf contenttype;
TVariantBuf widgetid;
TVariantBuf8 operation;
TVariantBuf8 trigger;
TLiwVariant variant;
variant.PushL();
if ( list->AtL( i, variant ) )
{
const CLiwMap* map( variant.AsMap() );
if( map->FindL( KPublisherId, variant ) )
{
variant.Get( publisher );
}
if ( publisher != publisherId )
{
// Not targeted to this publisher
continue;
}
// Check what triggered a notification
if ( map->FindL( KOperation, variant ) )
{
variant.Get( operation );
}
if ( operation == KExecute() )
{
if ( map->FindL( KActionTrigger, variant ) )
{
variant.Get( trigger );
}
if ( map->FindL( KContentId, variant ) )
{
variant.Get( widgetid );
}
if ( map->FindL( KContentType, variant ) )
{
variant.Get( contenttype );
}
if ( contenttype == KHsWidget() )
{
// HS specific notification
ProcessEvent( widgetid, trigger );
}
else
{
// Widget specific notification
HBufC* param = HBufC::NewLC( trigger.Length() );
param->Des().Copy( trigger );
iObserver.NotifyWidgetEvent(
widgetid, contenttype, *param );
CleanupStack::PopAndDestroy( param );
}
}
CleanupStack::PopAndDestroy(); // variant
}
}
CleanupStack::PopAndDestroy(); // listvariant
return KErrNone;
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::ProcessEvent()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::ProcessEvent( const TDesC& aWidgetId,
const TDesC8& aEvent ) const
{
if ( aEvent == KResume() )
{
iObserver.NotifyWidgetState(
aWidgetId, MHsWidgetObserver::EAlive );
}
else if ( aEvent == KSuspend() )
{
iObserver.NotifyWidgetState(
aWidgetId, MHsWidgetObserver::ESuspend );
}
else if ( aEvent == KOnline() )
{
iObserver.NotifyWidgetState(
aWidgetId, MHsWidgetObserver::EOnline );
}
else if ( aEvent == KOffline() )
{
iObserver.NotifyWidgetState(
aWidgetId, MHsWidgetObserver::EOffline );
}
else if ( aEvent == KSystemStartup() )
{
iObserver.NotifyWidgetStarted(
aWidgetId, MHsWidgetObserver::ESystemStart );
}
else if ( aEvent == KPageStartup() )
{
iObserver.NotifyWidgetStarted(
aWidgetId, MHsWidgetObserver::EPageStart );
}
else if ( aEvent == KWidgetStartup() )
{
iObserver.NotifyWidgetStarted(
aWidgetId, MHsWidgetObserver::EWidgetStart );
}
else if ( aEvent == KSystemShutdown() )
{
iObserver.NotifyWidgetStopped(
aWidgetId, MHsWidgetObserver::ESystemStop );
}
else if ( aEvent == KPageShutdown() )
{
iObserver.NotifyWidgetStopped(
aWidgetId, MHsWidgetObserver::EPageStop );
}
else if ( aEvent == KWidgetShutdown() )
{
iObserver.NotifyWidgetStopped(
aWidgetId, MHsWidgetObserver::EWidgetStop );
}
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::PublishTextL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::PublishTextL( const TDesC& aWidgetId,
const TDesC8& aElementId, const TDesC& aText )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CTextTransactionItem* item =
new ( ELeave ) CTextTransactionItem( aElementId, aText );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::PublishImageL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::PublishImageL( const TDesC& aWidgetId,
const TDesC8& aElementId, const CFbsBitmap* aImage, const CFbsBitmap* aMask )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
TInt imageHandle( KErrBadHandle );
TInt maskHandle( KErrBadHandle );
if ( aImage )
{
imageHandle = aImage->Handle();
}
if ( aMask )
{
maskHandle = aMask->Handle();
}
PublishImageL( aWidgetId, aElementId, imageHandle, maskHandle );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::PublishImageL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::PublishImageL( const TDesC& aWidgetId,
const TDesC8& aElementId, TInt aImageHandle, TInt aMaskHandle )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CImageTransactionItem* item =
new ( ELeave ) CImageTransactionItem(
aElementId, aImageHandle, aMaskHandle );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::PublishImageL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::PublishImageL( const TDesC& aWidgetId,
const TDesC8& aElementId, const TDesC& aSource )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CImageTransactionItem* item =
new ( ELeave ) CImageTransactionItem( aElementId, aSource );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::PublishStreamL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::PublishStreamL( const TDesC& aWidgetId,
const TDesC8& aElementId, const TDesC8& aStream )
{
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CDataTransactionItem* item =
new ( ELeave ) CDataTransactionItem( aElementId, aStream );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::CleanTextL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::CleanTextL( const TDesC& aWidgetId,
const TDesC8& aElementId )
{
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CTextTransactionItem* item =
new ( ELeave ) CTextTransactionItem( aElementId, KNullDesC() );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::CleanImageL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::CleanImageL( const TDesC& aWidgetId,
const TDesC8& aElementId )
{
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
CImageTransactionItem* item =
new ( ELeave ) CImageTransactionItem(
aElementId, KErrBadHandle, KErrBadHandle );
CleanupStack::PushL( item );
tr->AppendL( item );
CleanupStack::Pop( item );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::StartTransactionL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::StartTransactionL( const TDesC& aWidgetId )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
CTransaction* tr( Transaction( aWidgetId ) );
if ( tr )
{
// Transaction already started
User::Leave( KErrAlreadyExists );
}
// Create new transaction for this widget instance
tr = new ( ELeave ) CTransaction( aWidgetId );
CleanupStack::PushL( tr );
iTransactions.AppendL( tr );
CleanupStack::Pop( tr );
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::CommitTransactionL()
//
// -----------------------------------------------------------------------------
//
void CHsPublisherImpl::CommitTransactionL( const TDesC& aWidgetId )
{
__ASSERT_ALWAYS( iCpServiceAvailable, User::Invariant() );
CTransaction* tr( Transaction( aWidgetId ) );
if ( !tr )
{
// Transaction not started
User::Leave( KErrNotReady );
}
// Remove transaction
iTransactions.Remove( iTransactions.Find( tr ) );
// Transaction will be destroyed
CleanupStack::PushL( tr );
const RPointerArray< CTransactionItem >& items( tr->Items() );
if ( items.Count() == 0 )
{
// Nothing to publish
CleanupStack::PopAndDestroy( tr );
return;
}
CLiwGenericParamList& inParamList( iServiceHandler->InParamListL() );
CLiwGenericParamList& outParamList( iServiceHandler->OutParamListL() );
inParamList.AppendL( TLiwGenericParam(
KType, TLiwVariant( KCpData ) ) );
CLiwDefaultMap* cpdatamap = CLiwDefaultMap::NewLC();
const TDesC& publisherId( iObserver.Identity() );
cpdatamap->InsertL( KPublisherId, TLiwVariant( publisherId ) );
cpdatamap->InsertL( KContentType, TLiwVariant( KAll ) );
cpdatamap->InsertL( KContentId, TLiwVariant( aWidgetId ) );
CLiwDefaultMap* datamap = CLiwDefaultMap::NewLC();
for ( TInt i = 0; i < items.Count(); i++ )
{
CTransactionItem* item( items[i] );
CImageTransactionItem* image =
dynamic_cast< CImageTransactionItem* >( item );
CTextTransactionItem* text =
dynamic_cast< CTextTransactionItem* >( item );
CDataTransactionItem* data =
dynamic_cast< CDataTransactionItem* >( item );
if ( image )
{
const TDesC& source( image->Path() );
if ( source != KNullDesC )
{
datamap->InsertL( image->ElementId(),
TLiwVariant( source ) );
}
else
{
datamap->InsertL( image->ElementId(),
TLiwVariant( TInt32( image->ImageHandle() ) ) );
datamap->InsertL( image->ElementId(),
TLiwVariant( TInt32( image->MaskHandle() ) ) );
}
}
else if ( text )
{
datamap->InsertL( text->ElementId(),
TLiwVariant( text->Text() ) );
}
else if ( data )
{
datamap->InsertL( data->ElementId(),
TLiwVariant( data->Data() ) );
}
}
cpdatamap->InsertL( KDataMap, TLiwVariant( datamap ) );
inParamList.AppendL( TLiwGenericParam(
KItem, TLiwVariant( cpdatamap ) ) );
iCpsInterface->ExecuteCmdL( KAdd, inParamList, outParamList,
iEnablePersist ? 0 : KDisablePersist );
inParamList.Reset();
outParamList.Reset();
CleanupStack::PopAndDestroy( 3, tr ); // cpdatamap, datamap
}
// -----------------------------------------------------------------------------
// CHsPublisherImpl::Transaction()
//
// -----------------------------------------------------------------------------
//
CTransaction* CHsPublisherImpl::Transaction(
const TDesC& aWidgetId ) const
{
CTransaction* tr( NULL );
for ( TInt i = 0; i < iTransactions.Count(); i++ )
{
if ( *iTransactions[i] == aWidgetId )
{
tr = iTransactions[i];
break;
}
}
return tr;
}
// End of file