diff -r 000000000000 -r 2f259fa3e83a uifw/AknGlobalUI/OldStyleNotif/Src/AknNotifyPlugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/AknGlobalUI/OldStyleNotif/Src/AknNotifyPlugin.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,631 @@ +/* +* Copyright (c) 2002-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: +* +*/ + + +#include "AknNotifyPlugin.h" +#include + +#include +#include +#include +#include +#include + +#include // For NearestLanguageFile +#include + +#include +#include +#include +#include +#include "aknstatuspanedatapublisher.h" + +const TInt KIndicatorTap = 0xFFFF; + +void CAknMediatorEvent::RaiseEvent(TInt aId, const TDesC8& aBuf ) + { + TInt err(0); + if (iImpl) + { + if (iArray.Find(aId) == KErrNotFound) + { + err = iImpl->RegisterEvent( + KMediatorSecondaryDisplayDomain, + KAknSecondaryDisplayCategory, + aId, + TVersion(0,0,0), + TCapabilitySet(ECapabilityReadDeviceData)); + + if (!err) + { + iArray.Append(aId); + } + } + + if (!err) + { // ignore possible errors from now on... + iImpl->RaiseEvent( + KMediatorSecondaryDisplayDomain, + KAknSecondaryDisplayCategory, + aId, + TVersion(0,0,0), + aBuf); + } + } + } + +NONSHARABLE_CLASS(CAknIndicatorData): public CBase + { +public: + void HandleIndicatorChanged(TInt aIndicator, TInt aState) + { + TInt index = KErrNotFound; + for (TInt i = 0; i < iArray.Count(); i++) + { + if (iArray[i].iIndicator == aIndicator) + { + index = i; + break; + } + } + if (index == KErrNotFound) + { + const SAknSmallIndicatorData data= + { + aIndicator, aState + }; + if (aState != EAknIndicatorStateOff) + { + iArray.Append(data); // ignore return value + } + } + else + { + if (aState == EAknIndicatorStateOff) + { + iArray.Remove(index); + } + else + { + iArray[index].iIndicatorState = aState; + } + } + } + + void ExternalizeL(RWriteStream& aStream) const + { + TInt count = iArray.Count(); + aStream.WriteInt16L(count); + for (TInt i = 0; i < count; i++) + { + aStream.WriteInt32L(iArray[i].iIndicator); + aStream.WriteInt32L(iArray[i].iIndicatorState); + } + } + + ~CAknIndicatorData() + { + iArray.Close(); + } + + RArray iArray; + }; + + +void CAknPopupNotifierSubject::Release() + { + delete this; + } + +CAknPopupNotifierSubject::TNotifierInfo CAknPopupNotifierSubject::RegisterL() + { + iInfo.iUid=KAknPopupNotifierUid; + iInfo.iChannel=KAknPopupNotifierUid; // made up uid + iInfo.iPriority=ENotifierPriorityVHigh; + return iInfo; + } + +CAknPopupNotifierSubject::TNotifierInfo CAknPopupNotifierSubject::Info() const + { + return iInfo; + } + +TPtrC8 CAknPopupNotifierSubject::StartL(const TDesC8& aBuffer) + { + PopupL(aBuffer); + return KNullDesC8(); + } + +void CAknPopupNotifierSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, + const RMessagePtr2& aMessage) + { + PopupL(aBuffer); + aMessage.Complete(EEikNotExtRequestCompleted); + } + +void CAknPopupNotifierSubject::Cancel() + { + } + +TPtrC8 CAknPopupNotifierSubject::UpdateL(const TDesC8& aBuffer) + { + PopupL(aBuffer); + return KNullDesC8(); + } + +CAknPopupNotifierSubject* CAknPopupNotifierSubject::NewL() + { + CAknPopupNotifierSubject* self=new (ELeave) CAknPopupNotifierSubject(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CAknPopupNotifierSubject::CAknPopupNotifierSubject() + { + } + +void CAknPopupNotifierSubject::ConstructL() + { + } + +void CAknPopupNotifierSubject::PopupL(const TDesC8& aBuffer) + { + TPtrC msg(reinterpret_cast(aBuffer.Ptr()), aBuffer.Length()/2); + CEikonEnv::Static()->InfoWinL(_L("popup"), msg); + } + +void CAknSignalNotifierSubject::Release() + { + delete this; + } + +CAknSignalNotifierSubject::TNotifierInfo CAknSignalNotifierSubject::RegisterL() + { + iInfo.iUid=KAknSignalNotifierUid; + iInfo.iChannel=KAknSignalNotifierUid; + iInfo.iPriority=ENotifierPriorityVHigh; + return iInfo; + } + +CAknSignalNotifierSubject::TNotifierInfo CAknSignalNotifierSubject::Info() const + { + return iInfo; + } + +TPtrC8 CAknSignalNotifierSubject::StartL(const TDesC8& aBuffer) + { + HandleSignalMessageL(aBuffer); + return KNullDesC8(); + } + +void CAknSignalNotifierSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, + const RMessagePtr2& aMessage) + { + HandleSignalMessageL(aBuffer); + aMessage.Complete(EEikNotExtRequestCompleted); + } + +void CAknSignalNotifierSubject::Cancel() + { + } + +TPtrC8 CAknSignalNotifierSubject::UpdateL(const TDesC8& aBuffer) + { + HandleSignalMessageL(aBuffer); + return KNullDesC8(); + } + +CAknSignalNotifierSubject* CAknSignalNotifierSubject::NewL(CAknMediatorEvent* aEvent) + { + CAknSignalNotifierSubject* self=new (ELeave) CAknSignalNotifierSubject(); + CleanupStack::PushL(self); + self->iEvent = aEvent; + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CAknSignalNotifierSubject::CAknSignalNotifierSubject() + { + } + +CAknSignalNotifierSubject::~CAknSignalNotifierSubject() + { + } + +void CAknSignalNotifierSubject::ConstructL() + { + } + +void CAknSignalNotifierSubject::HandleSignalMessageL(const TDesC8& aBuffer) + { + SAknNotifierPackage* params = + (SAknNotifierPackage*)aBuffer.Ptr(); + + if ( aBuffer.Length() < 0 + || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage) + || params->iSignature != KAKNNOTIFIERSIGNATURE ) + { + User::Leave( KErrArgument ); + } + SAknSignalNotifyParams sParams = params->iParamData; // safe + + CEikServStatusPane* ssp = static_cast(CEikStatusPaneBase::Current()); + CAknStatusPaneDataPublisher* publisher = ssp->iDataPublisher; + + if ( sParams.iValue != EAknSignalStateNotChanged ) + { + publisher->SetSignalLevel(params->iParamData.iValue); + } + + if ( sParams.iGprsState != EAknSignalGprsIndicatorBgTypeWipe && + sParams.iGprsState != EAknNaviPaneBackgroundTypeSolid && + sParams.iGprsState >= 0 ) + { + publisher->SetSignalIcon( sParams.iGprsState ); + } + + publisher->PublishDataL(); + + TPckgBuf buf(sParams); + iEvent->RaiseEvent(EAknSignalIndicatorSDInfo, buf ); + } + +void CAknBatteryNotifierSubject::Release() + { + delete this; + } + +CAknBatteryNotifierSubject::TNotifierInfo CAknBatteryNotifierSubject::RegisterL() + { + iInfo.iUid=KAknBatteryNotifierUid; + iInfo.iChannel=KAknBatteryNotifierUid; + iInfo.iPriority=ENotifierPriorityVHigh; + return iInfo; + } + +CAknBatteryNotifierSubject::TNotifierInfo CAknBatteryNotifierSubject::Info() const + { + return iInfo; + } + +TPtrC8 CAknBatteryNotifierSubject::StartL(const TDesC8& aBuffer) + { + HandleBatteryMessageL(aBuffer); + return KNullDesC8(); + } + +void CAknBatteryNotifierSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, + const RMessagePtr2& aMessage) + { + HandleBatteryMessageL(aBuffer); + aMessage.Complete(EEikNotExtRequestCompleted); + } + +void CAknBatteryNotifierSubject::Cancel() + { + } + +TPtrC8 CAknBatteryNotifierSubject::UpdateL(const TDesC8& aBuffer) + { + HandleBatteryMessageL(aBuffer); + return KNullDesC8(); + } + +CAknBatteryNotifierSubject* CAknBatteryNotifierSubject::NewL(CAknMediatorEvent* aEvent) + { + CAknBatteryNotifierSubject* self=new (ELeave) CAknBatteryNotifierSubject(); + CleanupStack::PushL(self); + self->iEvent = aEvent; + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CAknBatteryNotifierSubject::CAknBatteryNotifierSubject() + { + } + +CAknBatteryNotifierSubject::~CAknBatteryNotifierSubject() + { + } + +void CAknBatteryNotifierSubject::ConstructL() + { + } + +void CAknBatteryNotifierSubject::HandleBatteryMessageL(const TDesC8& aBuffer) + { + SAknNotifierPackage* params = + (SAknNotifierPackage*)aBuffer.Ptr(); + + if ( aBuffer.Length() < 0 + || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage) + || params->iSignature != KAKNNOTIFIERSIGNATURE ) + { + User::Leave( KErrArgument ); + } + + CEikServStatusPane* ssp = static_cast(CEikStatusPaneBase::Current()); + CAknStatusPaneDataPublisher* publisher = ssp->iDataPublisher; + switch ( params->iParamData.iType ) + { + case SAknBatteryNotifyParams::ESetValue: + { + publisher->SetBatteryLevel(params->iParamData.iValue); + break; + } + case SAknBatteryNotifyParams::ERecharge: + { + publisher->SetRecharge(ETrue); + break; + } + case SAknBatteryNotifyParams::EStopRecharge: + { + publisher->SetRecharge(EFalse); + break; + } + case SAknBatteryNotifyParams::ENoRecharge: + { + publisher->SetRecharge(EFalse); + break; + } + case SAknBatteryNotifyParams::ESetState: + { + publisher->SetBatteryIcon( params->iParamData.iBatteryState ); + break; + } + default: + break; + } + publisher->PublishDataL(); + + TPckgBuf buf(params->iParamData ); + iEvent->RaiseEvent(EAknBatteryIndicatorSDInfo, buf); + } + +TInt CAknBatteryNotifierSubject::TickerCallback(TAny* aThis) + { + return static_cast(aThis)->DoTick(); + } + +TInt CAknBatteryNotifierSubject::DoTick() + { + return ETrue; + } + +void CAknSmallIndicatorSubject::Release() + { + delete this; + } + +CAknSmallIndicatorSubject::TNotifierInfo CAknSmallIndicatorSubject::RegisterL() + { + iInfo.iUid=KAknSmallIndicatorUid; + iInfo.iChannel=KAknSmallIndicatorUid; + iInfo.iPriority=ENotifierPriorityVHigh; + return iInfo; + } + +CAknSmallIndicatorSubject::TNotifierInfo CAknSmallIndicatorSubject::Info() const + { + return iInfo; + } + +TPtrC8 CAknSmallIndicatorSubject::StartL(const TDesC8& aBuffer) + { + HandleIndicatorMessageL(aBuffer); + return KNullDesC8(); + } + +void CAknSmallIndicatorSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, + const RMessagePtr2& aMessage) + { + HandleIndicatorMessageL(aBuffer); + aMessage.Complete(EEikNotExtRequestCompleted); + } + +void CAknSmallIndicatorSubject::Cancel() + { + } + +TPtrC8 CAknSmallIndicatorSubject::UpdateL(const TDesC8& aBuffer) + { + HandleIndicatorMessageL(aBuffer); + return KNullDesC8(); + } + +CAknSmallIndicatorSubject* CAknSmallIndicatorSubject::NewL(CAknMediatorEvent* aEvent) + { + CAknSmallIndicatorSubject* self=new (ELeave) CAknSmallIndicatorSubject(); + CleanupStack::PushL(self); + self->ConstructL(); + self->iEvent = aEvent; // do not store until leaving methods are clear + CleanupStack::Pop(); + return self; + } + +CAknSmallIndicatorSubject::CAknSmallIndicatorSubject() + { + } + +CAknSmallIndicatorSubject::~CAknSmallIndicatorSubject() + { + delete iIndicatorSDData; + delete iEvent; // bit nasty, but does not have really effect even if not deleted at all + } + + +void CAknSmallIndicatorSubject::ConstructL() + { + iIndicatorSDData = new (ELeave) CAknIndicatorData(); + } + +void CAknSmallIndicatorSubject::HandleIndicatorMessageL(const TDesC8& aBuffer) + { + SAknNotifierPackage* params = + (SAknNotifierPackage*)aBuffer.Ptr(); + + if ( aBuffer.Length() < 0 + || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage) + || params->iSignature != KAKNNOTIFIERSIGNATURE ) + { + User::Leave( KErrArgument ); + } + + CEikServStatusPane* ssp = static_cast(CEikStatusPaneBase::Current()); + CAknStatusPaneDataPublisher* publisher = ssp->iDataPublisher; + + if (params->iParamData.iValue == KIndicatorTap) + { + publisher->HandleIndicatorTapL(params->iParamData.iSmallIndicatorUid); + } + else + { + publisher->SetIndicatorState(params->iParamData.iSmallIndicatorUid, params->iParamData.iValue); + publisher->PublishDataL(); + + // publish current indicator status to coverui + iIndicatorSDData->HandleIndicatorChanged( + params->iParamData.iSmallIndicatorUid.iUid, + params->iParamData.iValue); + + CBufFlat* buf = CBufFlat::NewL(5); + CleanupStack::PushL(buf); + RBufWriteStream stream; + stream.Open(*buf); + CleanupClosePushL(stream); + stream << *iIndicatorSDData; + stream.CommitL(); + CleanupStack::PopAndDestroy(); // close stream + + iEvent->RaiseEvent(EAknSmallIndicatorSDInfo, buf->Ptr(0) ); + CleanupStack::PopAndDestroy(buf); + } + } + +void CAknIncallBubbleSubject::Release() + { + delete this; + } + + +CAknIncallBubbleSubject::TNotifierInfo CAknIncallBubbleSubject::RegisterL() + { + iInfo.iUid=KAknIncallBubbleUid; + iInfo.iChannel=KAknIncallBubbleUid; + iInfo.iPriority=ENotifierPriorityVHigh; + return iInfo; + } + +CAknIncallBubbleSubject::TNotifierInfo CAknIncallBubbleSubject::Info() const + { + return iInfo; + } + +TPtrC8 CAknIncallBubbleSubject::StartL(const TDesC8& aBuffer) + { + HandleIndicatorMessageL( aBuffer, 0 ); + return KNullDesC8(); + } + +void CAknIncallBubbleSubject::StartL(const TDesC8& aBuffer, TInt /*aReplySlot*/, + const RMessagePtr2& aMessage) + { + RThread clientThread; + TUint64 clientId = 0; + if ( KErrNone == aMessage.Client( clientThread ) ) + { + clientId = clientThread.Id().Id(); + } + clientThread.Close(); + HandleIndicatorMessageL( aBuffer, clientId ); + aMessage.Complete(EEikNotExtRequestCompleted); + } + +void CAknIncallBubbleSubject::Cancel() + { + } + +TPtrC8 CAknIncallBubbleSubject::UpdateL(const TDesC8& aBuffer) + { + HandleIndicatorMessageL(aBuffer,0); + return KNullDesC8(); + } + +CAknIncallBubbleSubject* CAknIncallBubbleSubject::NewL() + { + CAknIncallBubbleSubject* self=new (ELeave) CAknIncallBubbleSubject(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CAknIncallBubbleSubject::CAknIncallBubbleSubject() + { + } + +void CAknIncallBubbleSubject::ConstructL() + { + } + +void CAknIncallBubbleSubject::HandleIndicatorMessageL( const TDesC8& aBuffer , const TUint64& aClientId ) + { + SAknNotifierPackage* params = + (SAknNotifierPackage*)aBuffer.Ptr(); + + if ( aBuffer.Length() < 0 + || (TUint)aBuffer.Length() < sizeof(SAknNotifierPackage) + || params->iSignature != KAKNNOTIFIERSIGNATURE ) + { + User::Leave( KErrArgument ); + } + + CEikServStatusPane* ssp = static_cast(CEikStatusPaneBase::Current()); + CAknStatusPaneDataPublisher* publisher = ssp->iDataPublisher; + TInt flags = params->iParamData.iIncallBubbleFlags; + if ( flags & EAknStatusBubbleReservedInternal ) + { + if (flags & 4) + { + publisher->SetIncallBubbleAllowedInUsual( ETrue , aClientId ); + } + else if (flags & 2) + { + publisher->SetIncallBubbleAllowedInUsual( EFalse , aClientId ); + } + else if (flags & 1) + { + publisher->SetIncallBubbleAllowedInIdle( ETrue ); + } + else + { + publisher->SetIncallBubbleAllowedInIdle( EFalse ); + } + } + else + { + publisher->SetIncallBubbleFlags( flags ); + } + + publisher->PublishDataL(); + } + +