MCL/sf/mw/inputmethods: comparison textinput/peninputarc/src/peninputclient/penclientimpl.cpp

equal deleted inserted replaced

-:ac7e4d1d9209
+:ebd48d2de13c
 #include <apgcli.h>
 #include <s32mem.h>
 #include <coemain.h>
 #include <apgwgnam.h>
 #include "peninputclient.h"
-#ifndef FIX_FOR_NGA
-#define FIX_FOR_NGA
-#endif
 const TUint KDefaultMessageSlots = 4;
 const TInt KMaxSupportLanguages = 100;
 const TInt KMaxImeImplementations = 10;
 const TUid KSingletonClientId =
 {
 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)
+RPeninputServerImpl* RPeninputServerImpl::NewL()
 {
 //check for singleton existence
 CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId);
 CPenInputSingletonClient* client =
 static_cast<CPenInputSingletonClient*>(obj);
 if(client && client->IsValid())
 {
 RPeninputServerImpl* server = client->GetSingletonServer();
-TInt err = server->ServerReady() ? KErrNone : KErrLaunchingServer;
+return server;
-if ( aStatus )
+/*        if(iSingletonServer == 0 ) // second or later connecting from same client
 {
-User::RequestComplete( aStatus, err );
+error = KErrLaunchingServer;
-}
+}*/
-return server;
 }
 RPeninputServerImpl* self = new(ELeave) RPeninputServerImpl();
 CleanupStack::PushL(self);
-self->ConstructL(KSingletonClientId,aStatus);
+self->ConstructL(KSingletonClientId);
 CleanupStack::Pop(self);
 return self;
 }
 // ---------------------------------------------------------------------------
 {
 iObserver = 0;
 iIsForegroundSession = EFalse;
 iServerExit = EFalse;
 iLaunchServer = EFalse;
+iWaitScheduler = 0;
 iCurPenUiType = -1;
+iWaitScheduler = 0;
 iAppPrefferedUiMode = EPluginInputModeNone;
 iAutoOpenFlag = ETrue;
 iBackgroundCtrl = 0;
 iResourceChange = EFalse;
-iWaiterAo = NULL;
+}
-iPendingRequest = NULL;
-iServerReady = EFalse;
+void RPeninputServerImpl::ConstructL(const TUid& aUid)
-}
-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)
 }
 else
 client = new (ELeave)CPenInputSingletonClient(aUid,this);
 //Note: The client is destroyed by the control environment automatically
 //User::LeaveIfError(DoConnectL());
-TRAPD(err, DoConnectL(aStatus));
+TRAPD(err, DoConnectL());
 if(KErrNone != err)
 {
 client->SetInvalid();
 User::LeaveIfError(err);
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::DoConnectL
 // ---------------------------------------------------------------------------
 //
-TInt RPeninputServerImpl::DoConnectL(TRequestStatus* aStatus)
+TInt RPeninputServerImpl::DoConnectL()
 {
-iPendingRequest = aStatus;
 TInt error = KErrNone;
 /*************** Note ************************************************/
 // Multi-thread case is not considered here!
 /*************** Note ************************************************/
 if( error == KErrNotFound || error == KErrServerTerminated )
 {
 // server does not yet exist or it has terminated
 // try to create the server
+error = StartThreadL();
-if(!aStatus) //sync call
+if ( error == KErrNone || error == KErrAlreadyExists )
 {
-error = StartThreadL();
+// creation of server successfull, or some other client thread
-if(KErrNone == error)
+// created it first -> try to connect again
-{
+error = CreateSession( KPeninputServerName,
-error = CreateSession( KPeninputServerName,
+Version(),
-Version(),
+KDefaultMessageSlots );
-KDefaultMessageSlots,EIpcSession_Sharable);
-AddObserver();
-}
 }
 else
 {
-StartThreadAsyncL();
+return error;
-return KErrNone;
 }
 }
-else if ( error == KErrNone )//server alreay there
-{
+TThreadId srvThreadId;
-iServerReady = ETrue;
+if(KErrNone == error)
-AddObserver();
+{
+TIpcArgs arg;
-if(aStatus)
-	User::RequestComplete(iPendingRequest, error);
+TPckg<TThreadId> msg(srvThreadId);
-}
+arg.Set(KMsgSlot0,&msg);
+SendReceive(EPeninputRequestServerThreadId,arg);
+}
+iServerExit = EFalse;
+	//create default observer
+/*CPeninputServerObserver* observer = CPeninputServerObserver::NewL(this,
+srvThreadId,iObserver);*/
+if(iObserver)
+{
+iObserver->ReConstructL(srvThreadId);
+}
+else
+{
+iObserver = CPeninputServerObserver::NewL(this,srvThreadId);
+}
+TFindThread findPeninputServer( _L("*peninputserver*") );
+TFullName name;
+if (findPeninputServer.Next( name ) == KErrNone)
+{
+// if server is already running return immediately
+//return KErrAlreadyExists;
+RThread p;
+TInt r = p.Open(name);
+p.Close();
+}
 return error;
 }
-void RPeninputServerImpl::AddObserver()
-{
-TThreadId srvThreadId;
-	TIpcArgs arg;
-	TPckg<TThreadId> msg(srvThreadId);
-	arg.Set(KMsgSlot0,&msg);
-	SendReceive(EPeninputRequestServerThreadId,arg);
-iServerExit = EFalse;
-if(iObserver)
-{
-TRAP_IGNORE(iObserver->ReConstructL(srvThreadId));
-}
-else
-{
-TRAP_IGNORE(iObserver = CPeninputServerObserver::NewL(this,srvThreadId));
-}
-}
-TBool RPeninputServerImpl::ServerReady()
-	{
-	return iServerReady;
-	}
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::Version
 // ---------------------------------------------------------------------------
 //
 }
 if(aFlag)
 {
 //show the background control
-if(!iBackgroundCtrl && bmpHandle != -1)
+if(!iBackgroundCtrl)
 {
 iBackgroundCtrl = CPenUiBackgroundWnd::NewL(CCoeEnv::Static()->RootWin(),bmpHandle);
 }
 if(iBackgroundCtrl)
 iBackgroundCtrl->Show(extend, iGlobalNotes,
-iInternalPopup,priority, iResourceChange, iDataQueryIsPopped);
+iInternalPopup,priority, iResourceChange);
 }
 else //undim the window
 {
 if(iBackgroundCtrl)
-#ifdef FIX_FOR_NGA
+iBackgroundCtrl->Hide();
-{
-delete iBackgroundCtrl;
-iBackgroundCtrl = 0;
-}
-#else
-{
-iBackgroundCtrl->Hide();
-}
-#endif
 }
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::ActivateLayout
 // Activate/Deactivate a ui layout
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::IsDimmed
 // ---------------------------------------------------------------------------
 //
-TInt RPeninputServerImpl::SupportInputMode( TInt aLanguage )
+TInt RPeninputServerImpl::SupportInputMode()
 {
 TInt supportMode = 0;
 TIpcArgs arg;
 TPckg<TInt> msg(supportMode);
 arg.Set(KMsgSlot0,&msg);
-TPckg<TInt> language( aLanguage );
-arg.Set( KMsgSlot1,&language );
 SendReceive(EPeninputRequestSupportInputMode,arg);
 return supportMode;
 }
-TInt RPeninputServerImpl::SetInputLanguage( TInt aLanguage )
-	{
-	TIpcArgs arg;
-	TPckgC<TInt> msg(aLanguage);
-	arg.Set(KMsgSlot0,&msg);
-	return SendReceive(EPeninputRequestSetInputLanguage, arg);
-	}
 void RPeninputServerImpl::BackgroudDefaultOri( TInt aOri )
 {
 TIpcArgs arg;
 TPckgC<TInt> msg(aOri);
 arg.Set(KMsgSlot0,&msg);
 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
 // already created it.
 // ---------------------------------------------------------------------------
 //
 TInt RPeninputServerImpl::StartThreadL()
 {
+if(iWaitScheduler)
+return KErrLaunchingServer;
 TInt ret = KErrNone;
+// check if server already exists
+TFindServer findPeninputServer( KPeninputServerName );
+TFullName name;
+if (findPeninputServer.Next( name ) == KErrNone)
+{
+// if server is already running return immediately
+return KErrAlreadyExists;
+}
+// request status which gets signaled when server has been initialized
 RProcess server;
 User::LeaveIfError(server.Create(KPeninputServerExe,KNullDesC()));
+TRequestStatus status;
-TRequestStatus status;
+//User::WaitForRequest(status);
-server.Rendezvous(status);
+iObserver = CPeninputServerObserver::NewL(this,
+0);
+server.Rendezvous(iObserver->RequestStatus());
 server.Resume();
 server.Close();
-User::WaitForRequest(status);
+iWaitScheduler = CPeninputServerWaiter::NewL();
-if(ESignalServerReady != status.Int())
+iWaitScheduler->Start();
-ret = KErrGeneral;
+ret = iWaitScheduler->Error();
-else
-iServerReady = ETrue;
 return ret;
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::AddPeninputServerObserverL
 // Add observer
 // ---------------------------------------------------------------------------
 // Read buffer
 // ---------------------------------------------------------------------------
 //
 void RPeninputServerImpl::ReadIntArrayFromBufL(const TDesC8& aBuf, RArray<TInt>& aResult)
 {
-	CleanupClosePushL( aResult );
 	RDesReadStream readStream;
 	readStream.Open(aBuf);
 	CleanupClosePushL(readStream);
 	const TInt entryCount = readStream.ReadInt32L();
 		{
 		aResult.AppendL(readStream.ReadInt32L());
 		}
 CleanupStack::PopAndDestroy(&readStream);
-CleanupStack::Pop( &aResult );
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::SetForeground
 // Set current session to be foreground application session
 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
 // ---------------------------------------------------------------------------
 //
 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();
 }
 void RPeninputServerImpl::SetGlobalNotes(TBool aFlag)
 {
 iGlobalNotes = aFlag;
 }
-void RPeninputServerImpl::SetDataQueryPopped(TBool aFlag)
-	{
-	iDataQueryIsPopped = aFlag;
-	}
 void RPeninputServerImpl::SetInternalPopUp(TBool aFlag)
 {
 	iInternalPopup = aFlag;
 }
 TPckg<TBool> msg(bChange);
 arg.Set(KMsgSlot0,&msg);
 SendReceive(EPeninputRequestDimResChangeLayout,arg);
 }
-void RPeninputServerImpl::EnablePriorityChangeOnOriChange(TBool aEnabled)
-{
-	TIpcArgs arg;
-	TPckg<TBool> msg(aEnabled);
-arg.Set(KMsgSlot0,&msg);
-	SendReceive(EPeninputEnablePriorityChangeOnOriChange,arg);
-	}
 //end of class RPeninputServerImpl
 // Class CPeninputServerObserver
 TInt exitReason = 0;
 if(err == KErrNone) //thread is just closed
 {
 exitReason = srvThread.ExitReason();
 srvThread.Close();
-//iPeninputServer->OnServerReady(-1000);
+iPeninputServer->OnServerReady(-1000);
 }
 if(err != KErrNone || exitReason != 0) //server has exited
 {
 iServerExit  = ETrue;
 iPeninputServer->HandleServerExit();
 }
 }
 if(iStatus.Int() == ESignalServerReady) //server has started
 {
-//iPeninputServer->OnServerReady();
+iPeninputServer->OnServerReady();
 return;
 }
 //if there is also iUiActivationHandler, handle it first
 if(iUiActivationHandler)
 	ret = iUiActivationHandler->HandleServerEventL(iStatus.Int());
 TBool b = IsNonFocusing();
 SetFocusing(EFalse);
 }
 void CPenUiBackgroundWnd::Show(const TRect& aExtend, TBool aGlobalNotes,
-TBool aInternal, TInt aPriority, TBool aResource, TBool aDataQueryPopped)
+TBool aInternal, TInt aPriority, TBool aResource)
 {
 //Show the window will cause a focus group change in global notes showing case.
 if (!iBitmap)
 {
 return;
 iWndGroup.SetOrdinalPosition( 0, aPriority);
 Window().SetOrdinalPosition(0,aPriority);
-// The code runs well on 5.0 platform, but on tb92,
+Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
-// it will make the backgourd screen black purely.
-if( aDataQueryPopped )
-	{
-Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
-	}
 }
 else
 {
 Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
 }
 Window().Invalidate();
 DrawNow();
 }
 void CPenUiBackgroundWnd::Hide()
 {
 MakeVisible( EFalse );
 }
-void RPeninputServerImpl::OnServerStarted(TInt aErr)
-{
-if(KErrNone == aErr)
-{
-iServerReady = ETrue;
-//create session
-aErr = CreateSession( KPeninputServerName,
-Version(),
-KDefaultMessageSlots,EIpcSession_Sharable);
-	    if(KErrNone == aErr)
-	    	{
-	        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

branch	RCL_3
changeset 20	ebd48d2de13c
parent 15	6c2c2d3ab788
child 21	ecbabf52600f