diff -r 000000000000 -r eb1f2e154e89 textinput/peninputarc/src/peninputclient/penclientimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputarc/src/peninputclient/penclientimpl.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1574 @@ +/* +* Copyright (c) 2005-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: Implementation for peninput client +* +*/ + + + +#include "peninputclientserver.h" +#include "peninputclientimpl.h" +#include "peninputcmd.h" +#include "peninputsrvobserver.h" +#include +#include +#include +#include +#include +#include +#include +#include "peninputclient.h" +const TUint KDefaultMessageSlots = 4; + +const TInt KMaxSupportLanguages = 100; +const TInt KMaxImeImplementations = 10; +const TUid KSingletonClientId = + { + 0x10281854 + }; + + +TUid GetAppUidByWndGroupIdL( RWsSession &aWs, TInt aWndGroupId ) + { + CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(aWs,aWndGroupId); + TUid id = wg->AppUid(); + CleanupStack::PopAndDestroy(wg); + return id; + } +TUid AppUidFromWndGroupIdL(TInt aWndGrpId) + { + RWsSession &ws = CCoeEnv::Static()->WsSession(); + //TInt wgId =ws.GetFocusWindowGroup(); + CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(ws,aWndGrpId); + + TUid id = wg->AppUid(); + CleanupStack::PopAndDestroy(wg); + return id; + + } +TUid AppUidFromWndGroupId(TInt aWndGrpId) + { + TUid id = {0x00000000}; + TRAP_IGNORE(id = AppUidFromWndGroupIdL(aWndGrpId)); + return id; + } + +inline TUid GetFocusAppUid() + { + return AppUidFromWndGroupId(CCoeEnv::Static()->WsSession().GetFocusWindowGroup()); + } +TUid GetCurAppUid() + { + return AppUidFromWndGroupId(CCoeEnv::Static()->RootWin().Identifier()); + } + + + +CPeninputServerWaiter* CPeninputServerWaiter::NewL() + { + CPeninputServerWaiter* self = new(ELeave)CPeninputServerWaiter; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +void CPeninputServerWaiter::ConstructL() + { + iWaitScheduler = new(ELeave) CActiveSchedulerWait; + } + +CPeninputServerWaiter::~CPeninputServerWaiter() + { + delete iWaitScheduler; + } + +void CPeninputServerWaiter::Start() + { + iWaitScheduler->Start(); + } + +void CPeninputServerWaiter::Stop(TInt aFlag) + { + //if(aFlag) + iError = aFlag ? KErrNone : aFlag; + + iWaitScheduler->AsyncStop(); + } + + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::NewL +// --------------------------------------------------------------------------- +// +RPeninputServerImpl* RPeninputServerImpl::NewL(TRequestStatus* aStatus) + { + //check for singleton existence + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + CPenInputSingletonClient* client = + static_cast(obj); + if(client && client->IsValid()) + { + RPeninputServerImpl* server = client->GetSingletonServer(); + TInt err = server->ServerReady() ? KErrNone : KErrLaunchingServer; + User::RequestComplete(aStatus,err); + return server; + } + + RPeninputServerImpl* self = new(ELeave) RPeninputServerImpl(); + CleanupStack::PushL(self); + self->ConstructL(KSingletonClientId,aStatus); + CleanupStack::Pop(self); + return self; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RPeninputServerImpl +// --------------------------------------------------------------------------- +// +RPeninputServerImpl::RPeninputServerImpl() : iPosition(0,0),iSize(0,0) + { + iObserver = 0; + iIsForegroundSession = EFalse; + iServerExit = EFalse; + iLaunchServer = EFalse; + iCurPenUiType = -1; + iWaitScheduler = NULL; + iAppPrefferedUiMode = EPluginInputModeNone; + iAutoOpenFlag = ETrue; + iBackgroundCtrl = 0; + iResourceChange = EFalse; + iWaiterAo = NULL; + iPendingRequest = NULL; + iServerReady = EFalse; + } + +void RPeninputServerImpl::ConstructL(const TUid& aUid, TRequestStatus* aStatus) + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(aUid); + CPenInputSingletonClient* client; + //__ASSERT_ALWAYS(obj == NULL, User::Leave(KErrAlreadyExists)); + if(obj) + { + client = static_cast(obj); + client->ReplaceServer(this); + } + else + client = new (ELeave)CPenInputSingletonClient(aUid,this); + //Note: The client is destroyed by the control environment automatically + //User::LeaveIfError(DoConnectL()); + TRAPD(err, DoConnectL(aStatus)); + if(KErrNone != err) + { + client->SetInvalid(); + User::LeaveIfError(err); + } + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::DoConnectL +// --------------------------------------------------------------------------- +// +/*TInt RPeninputServerImpl::Connect() + { + //do nothing + return KErrNone; + } + */ +// --------------------------------------------------------------------------- +// RPeninputServerImpl::Close +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::Close() + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + CPenInputSingletonClient* client = + static_cast(obj); + if(client) + { + TInt ref = client->DecreaseRef(); + if (ref <= 0) + { + // delete the CCoeStatic object of CPenInputSingletonClient when + // Peninput server was closed. + // Basiccaly, all CCoeStatic objects are deleted in CCoeEnv destructor. + // However, it is necessary to delete the CCoeStatic object when + // changing from avkon fep to other fep. + delete client; + } + } + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::DoConnectL +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::DoConnectL(TRequestStatus* aStatus) + { + iPendingRequest = aStatus; + TInt error = KErrNone; + /*************** Note ************************************************/ + // Multi-thread case is not considered here! + /*************** Note ************************************************/ + + // try to connect to the server + error = CreateSession( KPeninputServerName, + Version(), + KDefaultMessageSlots,EIpcSession_Sharable); + + if( error == KErrNotFound || error == KErrServerTerminated ) + { + // server does not yet exist or it has terminated + // try to create the server + + if(!aStatus) //sync call + { + error = StartThreadL(); + if(KErrNone == error) + { + error = CreateSession( KPeninputServerName, + Version(), + KDefaultMessageSlots,EIpcSession_Sharable); + AddObserver(); + } + + } + else + { + StartThreadAsyncL(); + return KErrNone; + } + } + else //server alreay there + { + if(aStatus) + OnServerStarted(KErrNone); + else + AddObserver(); + } + return error; + } + +void RPeninputServerImpl::AddObserver() + { + TThreadId srvThreadId; + TIpcArgs arg; + + TPckg msg(srvThreadId); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestServerThreadId,arg); + + iServerExit = EFalse; + if(iObserver) + { + iObserver->ReConstructL(srvThreadId); + } + else + { + iObserver = CPeninputServerObserver::NewL(this,srvThreadId); + } + } + +TBool RPeninputServerImpl::ServerReady() + { + return iServerReady; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::Version +// --------------------------------------------------------------------------- +// +TVersion RPeninputServerImpl::Version(void) const + { + return( TVersion( KPeninputServerMajorVersionNumber, + KPeninputServerMinorVersionNumber, + KPeninputServerBuildVersionNumber ) ); + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RequestMessageNotification +// Register to require message notification +// --------------------------------------------------------------------------- +// + +void RPeninputServerImpl::RequestMessageNotification( TRequestStatus& aStatus ) + { + TInt data=0; + SendReceive( EPeninputServerRequestMessageNotification, TIpcArgs(data), aStatus ); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::CancelMessageNotification +// Cancel message notification +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::CancelMessageNotification() + { + SendReceive( EPeninputServerCancelMessageNotification); + } + + +void RPeninputServerImpl::DimUiLayout(TBool aFlag) + { + TRAP_IGNORE(DimUiLayoutL(aFlag)); + } + +void RPeninputServerImpl::DimUiLayoutL(TBool aFlag) + { + TInt priority = iPriority; + + TPckgC msg(aFlag); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + + TPckgC prioriryMsg(priority);//p + arg.Set(KMsgSlot1,&prioriryMsg); + + TInt bmpHandle = -1; + TPckg handleMsg(bmpHandle); + arg.Set(KMsgSlot2,&handleMsg); + + TRect extend; + TPckg posMsg(extend); + arg.Set(KMsgSlot3,&posMsg); + + if (iInternalPopup) + { + SendReceive(EPeninputRequestInternalDimLayout,arg); + } + else + { + SendReceive(EPeninputRequestDimLayout,arg); + } + + if(aFlag) + { + //show the background control + if(!iBackgroundCtrl) + { + iBackgroundCtrl = CPenUiBackgroundWnd::NewL(CCoeEnv::Static()->RootWin(),bmpHandle); + } + if(iBackgroundCtrl) + iBackgroundCtrl->Show(extend, iGlobalNotes, + iInternalPopup,priority, iResourceChange); + } + else //undim the window + { + if(iBackgroundCtrl) + iBackgroundCtrl->Hide(); + } + } +// --------------------------------------------------------------------------- +// RPeninputServerImpl::ActivateLayout +// Activate/Deactivate a ui layout +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::ActivateLayout(TBool aFlag) + { + if(iBackgroundCtrl && iBackgroundCtrl->IsVisible()) + iBackgroundCtrl->Hide(); + + //inform UI activation handler + for(TInt i = 0 ; i < iPenUiNotificationHandler.Count(); ++i) + { + if(iPenUiNotificationHandler[i].iType & iCurPenUiType) + { + if(aFlag) + iPenUiNotificationHandler[i].iHandler->OnPeninputUiActivated(); + else + iPenUiNotificationHandler[i].iHandler->OnPeninputUiDeactivated(); + } + } + + if ( aFlag || ( !aFlag && IsVisible() ) ) + { + TPckgC msg(aFlag); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + + TInt scrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode(); + TPckgC scrMsg(scrMode); + arg.Set(KMsgSlot1,&scrMsg); + SendReceive(EPeninputRequestActivateLayout,arg); + } + } + +void RPeninputServerImpl::ActivatePeninputInNotesL() + { + SendReceive(EPeninputRequestActivateLayoutInGlobalNotes); + } +// --------------------------------------------------------------------------- +// RPeninputServerImpl::GetServerEventData +// Retrieve server event data +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::GetServerEventData(TDes& aBuf) + { + if(iServerExit) // ??? + return -1; + + TIpcArgs arg; + aBuf.Zero(); + arg.Set(KMsgSlot0,aBuf.MaxLength()); + arg.Set(KMsgSlot1,&aBuf); + return SendReceive(EPeninputRequestGetServerEventData,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::ServerEventDfataNum +// Get the number of server event +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::ServerEventDataNum() + { + TInt num = -1; + TPckg msg(num); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + TInt err = SendReceive(EPeninputRequestGetServerEventDataNumber,arg); + if(err != KErrNone) + num = err;//set the error code + return num; + + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::ResourceChanged +// Tell server the client resource changed +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::ResourceChanged(TInt aType) + { + TIpcArgs arg; + TPckgC msg(aType); + arg.Set(KMsgSlot0,&msg); + + SendReceive(EPeninputRequestResourceChanged,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetUiLayoutPos +// Set ui layout position +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::SetUiLayoutPos(const TPoint& aPos) + { + TPckgC msg(aPos); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + return SendReceive(EPeninputRequestUiSetUiPos,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::UiLayoutPos +// get ui layout position +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::GetUiLayoutPosAndSize() + { + TPckg msgPos(iPosition); + TPckg msgSize(iSize); + + TIpcArgs arg; + arg.Set(KMsgSlot0,&msgPos); + arg.Set(KMsgSlot1,&msgSize); + SendReceive(EPeninputRequestUiGetUiPos,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServer::UiLayoutPos +// get ui layout position +// --------------------------------------------------------------------------- +// +TPoint RPeninputServerImpl::UiLayoutPos() + { + GetUiLayoutPosAndSize(); + return iPosition; + } + +// --------------------------------------------------------------------------- +// RPeninputServer::UiLayoutSize +// get ui layout size +// --------------------------------------------------------------------------- +// +TSize RPeninputServerImpl::UiLayoutSize() + { + GetUiLayoutPosAndSize(); + return iSize; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetUiLayoutId +// Create a ui layout +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::SetUiLayoutId(TUid aId) + { + TInt uid = aId.iUid; + + TPckgC msg(uid); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + + TPckg type(iCurPenUiType); + arg.Set(KMsgSlot2,&type); + return SendReceive(EPeninputRequestSetUiLayoutId,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetUiLayoutId +// Create a ui layout +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::SetUiLayoutId(TUid aId,const TDesC8& aData) + { + TInt uid = aId.iUid; + + TPckgC idMsg(uid); + TIpcArgs arg; + arg.Set(KMsgSlot0,&idMsg); + arg.Set(KMsgSlot1,&aData); + + TPckg type(iCurPenUiType); + arg.Set(KMsgSlot2,&type); + + return SendReceive(EPeninputRequestSetUiLayoutIdWithData,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::HandleCommand +// Ask ui layout handle command +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::HandleCommand(TInt aCmd,const TDesC8& aBuf) + { + TInt ret; + return HandleCommand(aCmd,aBuf,ret); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::HandleCommand +// Ask ui layout handle command +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::HandleCommand(TInt aCmd) + { + TInt ret; + return HandleCommand(aCmd,KNullDesC8,ret); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::HandleCommand +// Ask ui layout handle command +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::HandleCommand(TInt aCmd,const TDesC8& aBuf, TInt &aResult) + { + //if(iSingletonServer != this) + // return iSingletonServer->HandleCommand(aCmd,aBuf, aResult); + + if(!IsForegroundSession()) // not handle non-foregound session command + return EFalse; + + TIpcArgs arg; + TPckgC cmdMsg(aCmd); + arg.Set(KMsgSlot0,&cmdMsg); + + arg.Set(KMsgSlot1,&aBuf); + + TPckg retMsg(aResult); + arg.Set(KMsgSlot2,&retMsg); + + return SendReceive(EPeninputRequestHandleClientCommand,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::IsVisible +// --------------------------------------------------------------------------- +// +TBool RPeninputServerImpl::IsVisible() + { + TBool bVisible; + TIpcArgs arg; + + TPckg msg(bVisible); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestUiIsVisible,arg); + + return bVisible; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::IsVisible +// --------------------------------------------------------------------------- +// +TBool RPeninputServerImpl::IsDimmed() + { + TBool bDimmed; + TIpcArgs arg; + + TPckg msg(bDimmed); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestIsLayoutDimmed,arg); + + return bDimmed; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::IsDimmed +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::SupportInputMode() + { + TInt supportMode = 0; + TIpcArgs arg; + + TPckg msg(supportMode); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestSupportInputMode,arg); + + return supportMode; + } + +TInt RPeninputServerImpl::SetInputLanguage( TInt aLanguage ) + { + TIpcArgs arg; + TPckgC msg(aLanguage); + arg.Set(KMsgSlot0,&msg); + return SendReceive(EPeninputRequestSetInputLanguage, arg); + } + +void RPeninputServerImpl::BackgroudDefaultOri( TInt aOri ) + { + TIpcArgs arg; + TPckgC msg(aOri); + arg.Set(KMsgSlot0,&msg); + + SendReceive(EPeninputBackgroudDefaultOri,arg); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetAppBackgroundL +// Set server running in background +// --------------------------------------------------------------------------- +// +/*void RPeninputServerImpl::SetAppBackgroundL(RProcess& aServer) + { + CApaCommandLine* commandLine = CApaCommandLine::NewLC(); + commandLine->SetDocumentNameL(KNullDesC); + commandLine->SetExecutableNameL(KPeninputServerExe); + //if (aType == EBackgroundApplicationType ) + commandLine->SetCommandL( EApaCommandBackground ); + + commandLine->SetProcessEnvironmentL(aServer); + CleanupStack::PopAndDestroy(commandLine); + + } + */ + +TInt RPeninputServerImpl::StartThreadAsyncL() + { + //ASSERT_DUBUG(!iWaiterAo) + iWaiterAo = new CWaitingServerAo(this); + + + TInt ret = KErrNone; + + RProcess server; + User::LeaveIfError(server.Create(KPeninputServerExe,KNullDesC())); + + + server.Rendezvous(iWaiterAo->RequestStatus()); + server.Resume(); + server.Close(); + + return ret; + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::StartThread +// Creates the server thread on WINS and server process on MARM. +// Access to the thread/process creation is controlled with +// a global mutex which allows only one client thread to do +// the actual server creation in WINS. In MARM the creation of +// new server exits with KErrAlreadyExits if another thread +// already created it. +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::StartThreadL() + { + TInt ret = KErrNone; + + RProcess server; + User::LeaveIfError(server.Create(KPeninputServerExe,KNullDesC())); + + TRequestStatus status; + server.Rendezvous(status); + server.Resume(); + server.Close(); + + User::WaitForRequest(status); + if(ESignalServerReady != status.Int()) + ret = KErrGeneral; + else + iServerReady = ETrue; + return ret; + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::AddPeninputServerObserverL +// Add observer +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::AddPeninputServerObserverL( + MPeninputServerEventHandler* aHandler) + { + //can only set once + iObserver->AddEventHandler(aHandler); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RemovePeninputServerObserver +// Remove observer +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::RemovePeninputServerObserver() + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + if ( !obj ) + { + return; + } + delete iObserver; + iObserver = NULL; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RemovePeninputServerObserver +// Remove observer +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::RemovePeninputServerObserver( + MPeninputServerEventHandler* /*aHandler*/) + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + if ( !obj ) + { + return; + } + delete iObserver; + iObserver = NULL; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetDisplayMode +// Set the display mode +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::SetDisplayMode(TDisplayMode aDisplayMode, + TDisplayMode aMaskDisplayMode) + { + TPckgC msg(aDisplayMode); + TPckgC msg2(aMaskDisplayMode); + + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + arg.Set(KMsgSlot1,&msg2); + + SendReceive( EPeninputServerRequestSetDisplayMode, arg); + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::ClearServerEvent +// Set the display mode +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::ClearServerEvent() + { + + if(iObserver->IsActive()) + { + TInt data=0; + SendReceive(EPeninputServerClearServerEvent, TIpcArgs(data) ); + } + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::AfterUiNotification +// Tell server Ui notification has been processed. +// --------------------------------------------------------------------------- +// +/*void RPeninputServerImpl::Continue() + { + iSingletonServer->SendReceive(EPeninputRequestUiNotificationCompleted); + } + */ +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetDisplayMode +// To disable specified layouts at a time. +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::SetDisabledLayout( TInt aLayouts ) + { + + TIpcArgs arg; + arg.Set(KMsgSlot0,aLayouts); + + SendReceive( EPeninputRequestDisableLayout, arg ); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetDisplayMode +// To disable specified layouts at a time. +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::DisabledLayout() + { + TInt layouts = 0; + TIpcArgs arg; + + TPckg msg(layouts); + arg.Set(KMsgSlot0,&msg); + + SendReceive( EPeninputRequestGetDisableLayout, arg ); + return layouts; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::GetImePluginIdListL +// Get IME plugin list for a language +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::GetImePluginIdListL(TInt aLanguage, + TInt aPluginMode, + RArray& aImplmentationIds) + { + TInt size = sizeof(TInt) * (KMaxImeImplementations + 1); + HBufC8* buf = HBufC8::NewLC(size); + TPtr8 bufPtr = buf->Des(); + + TIpcArgs args; + args.Set(KMsgSlot0, aLanguage); + args.Set(KMsgSlot1, aPluginMode); + args.Set(KMsgSlot2, size); + args.Set(KMsgSlot3, &bufPtr); + aImplmentationIds.Reset(); + TInt err = SendReceive(EPenInputRequestGetImePluginIdList,args); + if( err == KErrNone ) + { + ReadIntArrayFromBufL(*buf, aImplmentationIds); + } + + CleanupStack::PopAndDestroy(buf); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::PenSupportLanguagesL +// Get pen supported langauge +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::PenSupportLanguagesL(RArray& aLanguageLists) + { + TInt size = sizeof(TInt) * (KMaxSupportLanguages + 1); + HBufC8* buf = HBufC8::NewLC(size); + TPtr8 bufPtr = buf->Des(); + + TIpcArgs args; + args.Set(KMsgSlot0, size); + args.Set(KMsgSlot1, &bufPtr); + aLanguageLists.Reset(); + TInt err = SendReceive(EPenInputRequestGetPenSupportLanguages,args); + if( err == KErrNone ) + { + TRAP(err, ReadIntArrayFromBufL(*buf, aLanguageLists)); + } + + CleanupStack::PopAndDestroy(buf); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::ReadIntArrayFromBufL +// Read buffer +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::ReadIntArrayFromBufL(const TDesC8& aBuf, RArray& aResult) + { + RDesReadStream readStream; + readStream.Open(aBuf); + CleanupClosePushL(readStream); + const TInt entryCount = readStream.ReadInt32L(); + + for(TInt i = 0; i < entryCount; ++i) + { + aResult.AppendL(readStream.ReadInt32L()); + } + + CleanupStack::PopAndDestroy(&readStream); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetForeground +// Set current session to be foreground application session +// --------------------------------------------------------------------------- +// +TBool RPeninputServerImpl::SetForeground(TBool aMustConnectFlag) + { + // if(iIsForegroundSession) + // return ETrue; + + TInt curAppId; + TRAP_IGNORE( curAppId = GetAppUidByWndGroupIdL(CCoeEnv::Static()->WsSession(), + CCoeEnv::Static()->RootWin().Identifier()).iUid); + TIpcArgs arg; + TPckgC idData(curAppId); + arg.Set(KMsgSlot0,&idData); + + TPckgC flagMsg(aMustConnectFlag); + arg.Set(KMsgSlot1,&flagMsg); + + TPckg retMsg(iIsForegroundSession); + arg.Set(KMsgSlot2,&retMsg); + + SendReceive(EPeninputRequestSetForeground,arg); + return iIsForegroundSession; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::LoseForeground +// Indicates current client lost foreground +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::LoseForeground() + { + iIsForegroundSession = EFalse; + SendReceive(EPeninputRequestRelinquishForeground); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::IsForeground +// Test whether this session is the forground application session +// --------------------------------------------------------------------------- +// +TBool RPeninputServerImpl::IsForeground() + { + TBool bIsForeground; + TIpcArgs arg; + + TPckg msg(bIsForeground); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestIsForeground,arg); + //__ASSERT_DEBUG(bIsForeground == iIsForegroundSession,User::Leave(-1)); + return bIsForeground; + + } + +/*void RPeninputServerImpl::DoAddPenUiActivationHandler() + { + TPckgC msg(iPenUiNotificationHandler->RegisteredType()); + TIpcArgs arg; + arg.Set(KMsgSlot0,&msg); + + iSingletonServer->SendReceive(EPeninputRequestAddUiObserver,arg); + + } + */ +void RPeninputServerImpl::OnServerReady( TBool aFlag) + { + //iLaunchServer = EFalse; + + iWaitScheduler->Stop(aFlag);//AsyncStop(); + //if(iPenUiNotificationHandler) + // DoAddPenUiActivationHandler(); + } +// --------------------------------------------------------------------------- +// RPeninputServerImpl::AddPenUiActivationHandler +// Add an UI activate/deactivation handler +// --------------------------------------------------------------------------- +// +TInt RPeninputServerImpl::AddPenUiActivationHandler( + MPenUiActivationHandler* aHandler,TInt aType) + { + iPenUiNotificationHandler.Append(TUiNotificationHandler(aHandler,aType)); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RemovePenUiActivationHandler +// Remove all UI activate/deactivation handler +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::RemovePenUiActivationHandler() + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + if ( !obj ) + { + return; + } + iPenUiNotificationHandler.Reset(); + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::RemovePenUiActivationHandler +// Remove an UI activate/deactivation handler +// Deprecated API +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::RemovePenUiActivationHandler(MPenUiActivationHandler + *aHandler) + { + CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId); + if ( !obj ) + { + return; + } + for(TInt i = iPenUiNotificationHandler.Count() - 1; i >= 0 ; --i) + { + if(aHandler == iPenUiNotificationHandler[i].iHandler) + { + iPenUiNotificationHandler.Remove(i); + } + } + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::UpdateAppInfo +// Update current application information +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::UpdateAppInfo(const TDesC& aInfo, TPeninputAppInfo aType) + { + TPckgC typeMsg(aType); + TIpcArgs arg; + arg.Set(KMsgSlot0,&typeMsg); + arg.Set(KMsgSlot1,&aInfo); + SendReceive(EPeninputRequestUpdateAppInfo,arg); + } + +void RPeninputServerImpl::HandleServerExit() + { + iServerExit = ETrue; + } + +TBool RPeninputServerImpl::IsForegroundSession() + { + return iIsForegroundSession; + } + +void RPeninputServerImpl::FinalClose() + { + delete iBackgroundCtrl; + + delete iWaitScheduler; + iWaitScheduler = 0; + iPenUiNotificationHandler.Close(); + delete iObserver; + iObserver = NULL; + + if ( iWaiterAo ) + { + iWaiterAo->Cancel(); + delete iWaiterAo; + iWaiterAo = NULL; + } + + RSessionBase::Close(); + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetAutoOpen +// Enable/disable the auto-open feature +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::SetAutoOpen(TBool aFlag) + { + iAutoOpenFlag = aFlag; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::AutoOpen +// get the the auto-open feature flag +// --------------------------------------------------------------------------- +// +TBool RPeninputServerImpl::AutoOpen() + { + return iAutoOpenFlag; + } + + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::SetPrefferredUiMode +// Set the app preferred pen ui mode. +// --------------------------------------------------------------------------- +// +void RPeninputServerImpl::SetPreferredUiMode(TPluginInputMode aMode) + { + iAppPrefferedUiMode = aMode; + } + +// --------------------------------------------------------------------------- +// RPeninputServerImpl::PrefferredUiMode +// Get the app preferred pen ui mode. +// --------------------------------------------------------------------------- +// +TPluginInputMode RPeninputServerImpl::PreferredUiMode() + { + return iAppPrefferedUiMode; + } + +void RPeninputServerImpl::SetGlobalNotes(TBool aFlag) + { + iGlobalNotes = aFlag; + } + +void RPeninputServerImpl::SetInternalPopUp(TBool aFlag) + { + iInternalPopup = aFlag; + } + +void RPeninputServerImpl::SetEditorPriority(TInt aFlag) + { + iPriority = aFlag; + } + + void RPeninputServerImpl::ClearTouchUI() + { + if(iBackgroundCtrl) + { + iBackgroundCtrl->Hide(); + iBackgroundCtrl->MakeVisible(EFalse); + } + } + +void RPeninputServerImpl::SetResourceChange(TBool aFlag) + { + iResourceChange = aFlag; + + + TBool bChange = aFlag; + TIpcArgs arg; + + TPckg msg(bChange); + arg.Set(KMsgSlot0,&msg); + SendReceive(EPeninputRequestDimResChangeLayout,arg); + } + +//end of class RPeninputServerImpl + + +// Class CPeninputServerObserver + +CPeninputServerObserver* CPeninputServerObserver::NewL( + RPeninputServerImpl* aServer, + TThreadId aSrvThreadId) + { + CPeninputServerObserver* self = new(ELeave) CPeninputServerObserver(aServer, + aSrvThreadId); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } +// --------------------------------------------------------------------------- +// CPeninputServerObserver::CPeninputServerObserver +// Constructor. Adds the active object to the active scheduler +// and issues a request for server notification. +// --------------------------------------------------------------------------- +// +CPeninputServerObserver::CPeninputServerObserver( + RPeninputServerImpl* aPeninputServer, + TThreadId aSrvThreadId) + :CActive( EPriorityHigh ), + iPeninputServer( aPeninputServer ), + iSrvThreadId(aSrvThreadId), + iServerExit(EFalse) + { + __ASSERT_ALWAYS( !IsActive(), User::Panic( KPeninputServerName, + KErrObserverAlreadyActive ) ); + //__ASSERT_DEBUG(aHandler, User::Panic( KPeninputServerName, + // KErrObserverNoHandler )); + + AddEventHandler(this); //set own as the dummy handler + /*if(aPrevObserver) + { + iHandler = aPrevObserver->iHandler; + iUiActivationHandler = aPrevObserver->iUiActivationHandler; + }*/ + // issue asynchronous request and set this object active + CActiveScheduler::Add( this ); + } + +void CPeninputServerObserver::ConstructL() + { + if(iPeninputServer->Handle() > 0) //valid one + iPeninputServer->RequestMessageNotification(iStatus); + SetActive(); + } + +void CPeninputServerObserver::ReConstructL(TThreadId aId) + { + iSrvThreadId = aId; + if(IsActive()) + { + Cancel(); + } + ConstructL(); + } +// --------------------------------------------------------------------------- +// CPeninputServerObserver::~CPeninputServerObserver +// Destructor. Cancels any outstanding requests +// --------------------------------------------------------------------------- +// +CPeninputServerObserver::~CPeninputServerObserver() + { + Cancel(); + } + +// --------------------------------------------------------------------------- +// CPeninputServerObserver::DoCancel +// Cancels the notification requests +// --------------------------------------------------------------------------- +// +void CPeninputServerObserver::DoCancel() + { + if(!iServerExit) + iPeninputServer->CancelMessageNotification(); + } + + +// --------------------------------------------------------------------------- +// CPeninputServerObserver::RunL +// --------------------------------------------------------------------------- +// +void CPeninputServerObserver::RunL() + { + + //iHandler is always there. No need to check it + TInt ret = EFalse; + + if(iStatus.Int() < 0) + { + //check server status + RThread srvThread; + TInt err = srvThread.Open(iSrvThreadId); + TInt exitReason = 0; + if(err == KErrNone) //thread is just closed + { + exitReason = srvThread.ExitReason(); + srvThread.Close(); + iPeninputServer->OnServerReady(-1000); + } + if(err != KErrNone || exitReason != 0) //server has exited + { + iServerExit = ETrue; + iPeninputServer->HandleServerExit(); + iHandler->HandleServerEventL(ESignalServerExit); + return; + } + } + + if(iStatus.Int() == ESignalServerReady) //server has started + { + iPeninputServer->OnServerReady(); + return; + } + //if there is also iUiActivationHandler, handle it first + if(iUiActivationHandler) + ret = iUiActivationHandler->HandleServerEventL(iStatus.Int()); + + if(!ret) + ret = iHandler->HandleServerEventL(iStatus.Int()); + // re-issue request if request + if(ret) + { + iPeninputServer->RequestMessageNotification(iStatus); + SetActive(); + } + } + +// --------------------------------------------------------------------------- +// CPeninputServerObserver::RunError +// --------------------------------------------------------------------------- +// +TInt CPeninputServerObserver::RunError(TInt /*aError*/) + { + // re-issue request + iPeninputServer->RequestMessageNotification(iStatus); + SetActive(); + + return KErrNone; + } + +void CPeninputServerObserver::AddEventHandler(MPeninputServerEventHandler* aHandler) + { +// if(iHandler) +// return; + iHandler = aHandler; + } + +void CPeninputServerObserver::AddUiActivationHandler(MPeninputServerEventHandler* aHandler) + { + iUiActivationHandler = aHandler; + } + +TBool CPeninputServerObserver::HandleServerEventL(TInt /*aEventId*/) + { + //consume all events + return ETrue; + } + + +TUiNotificationHandler::TUiNotificationHandler( + MPenUiActivationHandler* aHandler,TInt aType) + :iHandler(aHandler),iType(aType) + { + } + +//class CPenInputSingletonClient +CPenInputSingletonClient::CPenInputSingletonClient(const TUid& aUid, + RPeninputServerImpl* aServer) + : CCoeStatic(aUid,EApp), + iServer(aServer),iReferrence(1),iIsValid(ETrue) + { + } + +RPeninputServerImpl* CPenInputSingletonClient::GetSingletonServer() + { + RPeninputServerImpl* ret = 0; + if(iIsValid && iServer->Handle()) + { + ++iReferrence; + ret = iServer; + } + return ret; + } + +TInt CPenInputSingletonClient::DecreaseRef() + { + --iReferrence; + if( 0 == iReferrence && iIsValid) + { + iServer->FinalClose(); + delete iServer; + iServer = 0; + iIsValid = EFalse; + } + return iReferrence; + } + +TBool CPenInputSingletonClient::IsValid() + { + return iIsValid; + } + +void CPenInputSingletonClient::SetInvalid() + { + iIsValid = EFalse; + } + +void CPenInputSingletonClient::ReplaceServer(RPeninputServerImpl* aServer) + { + iServer = aServer; + iIsValid = ETrue; + iReferrence = 1; + } + +CPenInputSingletonClient::~CPenInputSingletonClient() + { + if ( iServer ) + { + iServer->FinalClose(); + delete iServer; + } + } + +//for class background wnd + +TBool IsGlobalNotesApp(TUid& aUid) + { + const TInt KAknCapServerUid = 0x10207218; + const TInt KAknNotifySrvUid = 0x10281EF2; + + if(aUid.iUid == KAknCapServerUid || aUid.iUid == KAknNotifySrvUid) + return ETrue; + return EFalse; + } + + +CPenUiBackgroundWnd* CPenUiBackgroundWnd::NewL(RWindowGroup& aWndGroup,TInt aBmpHandle) + { + CPenUiBackgroundWnd* self = new(ELeave) CPenUiBackgroundWnd(aWndGroup); + CleanupStack::PushL(self); + self->ConstructL(aBmpHandle); + CleanupStack::Pop(self); + return self; + } + +CPenUiBackgroundWnd::CPenUiBackgroundWnd(RWindowGroup& aWndGroup) + :iWndGroup(aWndGroup) + { + } + +CPenUiBackgroundWnd::~CPenUiBackgroundWnd() + { + delete iBitmap; + + // if (iBitmapCpoy) + { + // delete iBitmapCpoy; + // iBitmapCpoy = NULL; + } + } + +void CPenUiBackgroundWnd::CreateBitmapL(TInt aBmpHandle) + { + iBitmap = new (ELeave) CFbsBitmap; + TInt ret = iBitmap->Duplicate(aBmpHandle); + + if(KErrNone != ret) + { + delete iBitmap; + iBitmap = NULL; + } + } + +void CPenUiBackgroundWnd::ConstructL(TInt aBmpHandle) + { + CreateWindowL(iWndGroup); + SetComponentsToInheritVisibility(); + + Window().SetRequiredDisplayMode( EColor16MA ); + MakeVisible( EFalse ); + CreateBitmapL(aBmpHandle); + TBool b = IsNonFocusing(); + SetFocusing(EFalse); + } + +void CPenUiBackgroundWnd::Show(const TRect& aExtend, TBool aGlobalNotes, + TBool aInternal, TInt aPriority, TBool aResource) + { + //Show the window will cause a focus group change in global notes showing case. + if (!iBitmap) + { + return; + } + TUid curApp = GetCurAppUid(); + TUid focusApp = GetFocusAppUid(); + //dim effect due to global notes will not done by background control + if(!aInternal || aGlobalNotes) + return; + +// if (iBitmapCpoy) + { +// delete iBitmapCpoy; +// iBitmapCpoy = NULL; + } + SetRect(aExtend); + TRAP_IGNORE(ActivateL()); + MakeVisible(ETrue); + if (!aResource) + { + RWsSession &ws = CCoeEnv::Static()->WsSession(); + TInt wgId =ws.GetFocusWindowGroup(); + TInt priority = ws.GetWindowGroupOrdinalPriority(wgId); + + iWndGroup.SetOrdinalPosition( 0, aPriority); + + Window().SetOrdinalPosition(0,aPriority); + + Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly); + } + else + { + Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly); + } + + Window().Invalidate(); + DrawNow(); + } + +void CPenUiBackgroundWnd::Draw(const TRect& aRect) const + { + CWindowGc& gc = SystemGc(); + + // if (iBitmapCpoy) + // gc.BitBlt(aRect.iTl,iBitmapCpoy,aRect); + if (iBitmap) + gc.BitBlt(aRect.iTl,iBitmap,aRect); + + } + +void CPenUiBackgroundWnd::Hide() + { + MakeVisible( EFalse ); + } + + +void RPeninputServerImpl::OnServerStarted(TInt aErr) + { + if(KErrNone == aErr) + { + iServerReady = ETrue; + } + + //create session + + TInt error = CreateSession( KPeninputServerName, + Version(), + KDefaultMessageSlots,EIpcSession_Sharable); + + if(KErrNone == error) + AddObserver(); + + User::RequestComplete(iPendingRequest, aErr); + } + +CWaitingServerAo::CWaitingServerAo(RPeninputServerImpl* aClient) + : CActive(CActive::EPriorityStandard), + iClient(aClient) + { + CActiveScheduler::Add(this); + SetActive(); + iStatus = KRequestPending; + } + + +void CWaitingServerAo::RunL() + { + TInt err = ESignalServerReady == iStatus.Int() ? KErrNone : KErrGeneral; + + iClient->OnServerStarted(err); + } + +void CWaitingServerAo::DoCancel() + { + } +TInt CWaitingServerAo::RunError(TInt /*aError*/) + { + return KErrNone; + } + +TRequestStatus& CWaitingServerAo::RequestStatus() + { + return iStatus; + } +// End of File +