/*
* Copyright (c) 2009 - 2010 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: MCS plugin publisher
*
*/
// System includes
#include <ecom/ecom.h>
#include <ecom/implementationproxy.h>
#include <gulicon.h>
#include <mcsmenuitem.h>
// User includes
#include <aicontentobserver.h>
#include <aistrcnv.h>
#include <aiutility.h>
#include <aipluginsettings.h>
#include "carouselpluginuids.hrh"
#include "carouselplugin.h"
#include "carouselplugindata.h"
#include "carouselpluginengine.h"
// Constants
const TUint KPluginNameSeprator = '/';
const TInt KImplUidMCSPlugin = AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_CAROUSELPLUGIN;
_LIT( KEventNameLaunchByIndex, "LaunchByIndex" );
_LIT( KEventNameShowSettings, "ShowSettings" );
_LIT( KContentItemTypeText, "text" );
_LIT( KContentItemTypeImage, "image" );
_LIT( KContentItemTypeData, "data" );
const TImplementationProxy KImplementationTable[] =
{
IMPLEMENTATION_PROXY_ENTRY( KImplUidMCSPlugin, CCarouselPlugin::NewL )
};
class CPublishItem : public CBase
{
public:
~CPublishItem();
CPublishItem();
CGulIcon* icon;
HBufC* text;
TBool last;
};
CPublishItem::CPublishItem()
{
}
CPublishItem::~CPublishItem()
{
delete text;
}
// ======== LOCAL FUNCTIONS ========
// ======== MEMBER FUNCTIONS ========
// ----------------------------------------------------------------------------
// CMCSPlugin::NewL
//
// ----------------------------------------------------------------------------
//
CCarouselPlugin* CCarouselPlugin::NewL()
{
CCarouselPlugin* self = new ( ELeave ) CCarouselPlugin;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// CMCSPlugin::CMCSPlugin
//
// ----------------------------------------------------------------------------
//
CCarouselPlugin::CCarouselPlugin()
{
}
// ----------------------------------------------------------------------------
// CMCSPlugin::ConstructL
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::ConstructL()
{
}
// ----------------------------------------------------------------------------
// Destructor
// Deletes all data created to heap
// ----------------------------------------------------------------------------
//
CCarouselPlugin::~CCarouselPlugin()
{
Release( iContent );
delete iEngine;
iObservers.Close();
DeleteContentModel();
}
// ----------------------------------------------------------------------------
// CMCSPlugin::PublishL
// Publishes the all the items
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::PublishL()
{
TInt err( KErrNone );
TInt observers( iObservers.Count() );
TInt transactionId( reinterpret_cast<TInt>( this ) );
TInt menuItems ( iEngine->MenuItemCount() );
for ( TInt i = 0; i < observers; i++ )
{
MAiContentObserver* observer( iObservers[ i ] );
err = observer->StartTransaction( transactionId );
if ( err == KErrNotSupported )
{
return;
}
// Publish content to all items
for ( TInt j = 0; j < menuItems; j++ )
{
// Index has to start from 1 ( j + 1 )
PublishLItemL( *observer, iEngine->MenuDataL( j ), ( j + 1 ) );
}// shortcut count
if ( err == KErrNone )
{
err = observer->Commit( transactionId );
if ( err == KErrNotSupported )
{
return;
}
}
}//observers
// Set all items not dirty.
for ( TInt j = 0; j < menuItems; j++ )
{
iEngine->MenuDataL( j ).SetDirty( EFalse );
}
}
// ----------------------------------------------------------------------------
// CMCSPlugin::PublishLItemL
// Publishes one item to given index
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::PublishLItemL( MAiContentObserver& aObserver,
CCarouselData& aData, TInt aIndex )
{
if( !aData.IsDirty() )
{
return;
}
CMenuItem* item = iEngine->FetchMenuItemL( aData );
CleanupStack::PushL( item );
if ( iContentModel[0].type == KAiContentTypeData )
{
if(TPtrC16( ( const TText16* ) iContentModel[ 0 ].cid ) == _L("widget") )
{
CGulIcon* icon( iEngine->ItemIconL( item, _L("icon")));
icon->SetBitmapsOwnedExternally( ETrue );
aObserver.Publish( *this, 0, TPckgC<TAny*>( icon ), aIndex - 1 );
}
}
CleanupStack::PopAndDestroy( item );
}
// ----------------------------------------------------------------------------
// PublishEditorItemsL
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::PublishEditorItemsL()
{/*
RArray<TMenuItem> items = iEngine->MenuItemsL();
CleanupClosePushL( items );
TInt count( items.Count());
for( TInt i = 0; i < count; i++ )
{
CMenuItem* item( iEngine->FetchMenuItemL( items[i]));
CleanupStack::PushL( item );
CGulIcon* icon( iEngine->ItemIconL( *item, _L("icon")));
TPtrC name( iEngine->ItemTextL( *item, _L("long_name") ));
CPublishItem* pItem = new CPublishItem;
pItem->icon = icon;
pItem->text = name.AllocL();
if( i < count - 1 )
{
pItem->last = EFalse;
}
else
{
pItem->last = ETrue;
}
iObservers[0]->Publish( *this, 0, TPckgC<TAny*>( pItem), i );
delete pItem;
CleanupStack::PopAndDestroy( item );
}
CleanupStack::PopAndDestroy( &items );
*/
}
// ----------------------------------------------------------------------------
// CMCSPlugin::Start
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::Start( TStartReason /*aReason*/ )
{
}
// ----------------------------------------------------------------------------
// CMCSPlugin::Stop
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::Stop( TStopReason /*aReason*/ )
{
}
// ----------------------------------------------------------------------------
// CMCSPlugin::Resume
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::Resume( TResumeReason aReason )
{
if ( aReason == EForeground )
{
iEngine->SetBackupRestore( EFalse );
if ( PublishRequired() )
{
TRAP_IGNORE( PublishL() );
}
}
}
// ----------------------------------------------------------------------------
// CMCSPlugin::Suspend
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::Suspend( TSuspendReason aReason )
{
if ( aReason == EGeneralThemeChange )
{
TInt dataCount( iEngine->MenuItemCount() );
for ( TInt i = 0; i < dataCount; i++ )
{
TRAP_IGNORE( iEngine->MenuDataL( i ).SetDirty( ETrue ) );
}
}
else if ( aReason == EBackupRestore )
{
// Prevent item launching during backup / restore
iEngine->SetBackupRestore( ETrue );
}
}
// ----------------------------------------------------------------------------
// CMCSPlugin::SubscribeL
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::SubscribeL( MAiContentObserver& aObserver )
{
iObservers.AppendL( &aObserver );
}
// ----------------------------------------------------------------------------
// CMCSPlugin::ConfigureL
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::ConfigureL( RAiSettingsItemArray& aSettings )
{
iEngine = CCarouselPluginEngine::NewL( *this, PublisherInfo().Namespace() );
TLinearOrder<MAiPluginSettings> sortMethod( CCarouselPlugin::CompareItems );
RAiSettingsItemArray contentItemsArr;
TInt count( aSettings.Count() );
for ( TInt i = 0; i < count; i++ )
{
MAiPluginSettings* setting( aSettings[ i ] );
if( setting->AiPluginItemType() == EAiPluginContentItem )
{
MAiPluginContentItem& contItem( setting->AiPluginContentItem() );
TPtrC name( contItem.Name() );
TPtrC type( contItem.Type() );
contentItemsArr.InsertInOrder( setting, sortMethod );
}
}
iDataCount = contentItemsArr.Count();
if ( iDataCount > 0 )
{
// Create the dynamic content Model
DeleteContentModel();
iContentModel = new ( ELeave ) TAiContentItem[ iDataCount ];
for ( TInt i = 0; i < iDataCount; i++ )
{
iContentModel[i].id = i;
MAiPluginContentItem& contentItem(
contentItemsArr[ i ]->AiPluginContentItem() );
if( contentItem.Type() == KContentItemTypeText )
{
// text
iContentModel[i].type = KAiContentTypeText;
}
if( contentItem.Type() == KContentItemTypeImage )
{
// image
iContentModel[i].type = KAiContentTypeBitmap;
}
else if(contentItem.Type() == KContentItemTypeData )
{
// data
iContentModel[i].type = KAiContentTypeData;
}
TInt pos( contentItem.Name().Locate( KPluginNameSeprator ) );
HBufC* contentId = HBufC::NewL( contentItem.Name().Length() );
CleanupStack::PushL( contentId );
TPtr ptr( contentId->Des() );
ptr = contentItem.Name().Mid( pos + 1 );
TInt sizeOfContentId( ptr.Size() + sizeof( wchar_t ) );
iContentModel[i].cid =
static_cast<const wchar_t*>( User::AllocL( sizeOfContentId ) );
Mem::Copy( ( TAny* )iContentModel[i].cid,
ptr.PtrZ(), sizeOfContentId );
CleanupStack::PopAndDestroy( contentId );
}
iContent = AiUtility::CreateContentItemArrayIteratorL(
iContentModel, iDataCount );
}
contentItemsArr.Reset();
// We own the array so destroy it
aSettings.ResetAndDestroy();
}
// ----------------------------------------------------------------------------
// CMCSPlugin::GetProperty
//
// ----------------------------------------------------------------------------
//
TAny* CCarouselPlugin::GetProperty( TProperty aProperty )
{
if( aProperty == EPublisherContent )
{
return static_cast< MAiContentItemIterator* >( iContent );
}
return NULL;
}
// ----------------------------------------------------------------------------
// CMCSPlugin::HandleEvent
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::HandleEvent( const TDesC& aEventName, const TDesC& aParam )
{
if( aEventName == KEventNameLaunchByIndex )
{
TInt32 index;
AiUtility::ParseInt( index, aParam );
TRAP_IGNORE( iEngine->LaunchItemL( index - 1 ) );
}
else if( aEventName == KEventNameShowSettings )
{
TRAP_IGNORE( iEngine->ShowSettingsL() );
}
else if( aEventName == _L("ShowEditor"))
{
TRAP_IGNORE( PublishEditorItemsL() );
}
}
// ----------------------------------------------------------------------------
// CMCSPlugin::CompareItems
//
// ----------------------------------------------------------------------------
//
TInt CCarouselPlugin::CompareItems( const MAiPluginSettings& aFirst,
const MAiPluginSettings& aSecond )
{
MAiPluginSettings& first = const_cast<MAiPluginSettings&>(aFirst);
MAiPluginSettings& second = const_cast<MAiPluginSettings&>(aSecond);
return first.AiPluginContentItem().Name().CompareC(second.AiPluginContentItem().Name());
}
// ----------------------------------------------------------------------------
// CMCSPlugin::DeleteContentModel
//
// ----------------------------------------------------------------------------
//
void CCarouselPlugin::DeleteContentModel()
{
if( iContentModel )
{
for ( TInt i = 0; i < iDataCount; i++ )
{
if( iContentModel[i].cid )
{
TAny* cell = static_cast<TAny*>( const_cast<wchar_t*>( iContentModel[i].cid ) );
User::Free( cell ); // Originally allocated with User::Alloc, so delete
// with correlating method.
iContentModel[i].cid = NULL;
}
}
delete iContentModel;
iContentModel = NULL;
}
}
// ----------------------------------------------------------------------------
// CMCSPlugin::PublishRequired
//
// ----------------------------------------------------------------------------
//
TBool CCarouselPlugin::PublishRequired() const
{
TInt count( iEngine->MenuItemCount() );
TBool retval( EFalse );
for ( TInt i = 0; !retval && i < count; i++ )
{
TRAP_IGNORE( retval = iEngine->MenuDataL( i ).IsDirty() );
}
return retval;
}
// ======== GLOBAL FUNCTIONS ========
// ----------------------------------------------------------------------------
// Constructs and returns an application object.
// ----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(
TInt& aTableCount )
{
aTableCount = sizeof( KImplementationTable ) /
sizeof( TImplementationProxy );
return KImplementationTable;
}
// End of file