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

equal deleted inserted replaced

-:ebd48d2de13c
+:ecbabf52600f
 #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()
+RPeninputServerImpl* RPeninputServerImpl::NewL(TRequestStatus* aStatus)
 {
 //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;
+if ( aStatus )
+{
+User::RequestComplete( aStatus, err );
+}
 return server;
-/*        if(iSingletonServer == 0 ) // second or later connecting from same client
-{
-error = KErrLaunchingServer;
-}*/
 }
 RPeninputServerImpl* self = new(ELeave) RPeninputServerImpl();
 CleanupStack::PushL(self);
-self->ConstructL(KSingletonClientId);
+self->ConstructL(KSingletonClientId,aStatus);
 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;
-void RPeninputServerImpl::ConstructL(const TUid& aUid)
+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)
 }
 else
 client = new (ELeave)CPenInputSingletonClient(aUid,this);
 //Note: The client is destroyed by the control environment automatically
 //User::LeaveIfError(DoConnectL());
-TRAPD(err, DoConnectL());
+TRAPD(err, DoConnectL(aStatus));
 if(KErrNone != err)
 {
 client->SetInvalid();
 User::LeaveIfError(err);
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::DoConnectL
 // ---------------------------------------------------------------------------
 //
-TInt RPeninputServerImpl::DoConnectL()
+TInt RPeninputServerImpl::DoConnectL(TRequestStatus* aStatus)
 {
+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 )
 {
-// creation of server successfull, or some other client thread
+error = StartThreadL();
-// created it first -> try to connect again
+if(KErrNone == error)
-error = CreateSession( KPeninputServerName,
+{
-Version(),
+error = CreateSession( KPeninputServerName,
-KDefaultMessageSlots );
+Version(),
+KDefaultMessageSlots,EIpcSession_Sharable);
+AddObserver();
+}
 }
 else
 {
-return error;
+StartThreadAsyncL();
+return KErrNone;
 }
 }
+else if ( error == KErrNone )//server alreay there
+{
+iServerReady = ETrue;
+AddObserver();
+if(aStatus)
+	User::RequestComplete(iPendingRequest, error);
+}
+return error;
+}
+void RPeninputServerImpl::AddObserver()
+{
 TThreadId srvThreadId;
-if(KErrNone == error)
+	TIpcArgs arg;
-{
-TIpcArgs arg;
+	TPckg<TThreadId> msg(srvThreadId);
+	arg.Set(KMsgSlot0,&msg);
-TPckg<TThreadId> msg(srvThreadId);
+	SendReceive(EPeninputRequestServerThreadId,arg);
-arg.Set(KMsgSlot0,&msg);
-SendReceive(EPeninputRequestServerThreadId,arg);
-}
 iServerExit = EFalse;
-	//create default observer
-/*CPeninputServerObserver* observer = CPeninputServerObserver::NewL(this,
-srvThreadId,iObserver);*/
 if(iObserver)
 {
-iObserver->ReConstructL(srvThreadId);
+TRAP_IGNORE(iObserver->ReConstructL(srvThreadId));
 }
 else
 {
-iObserver = CPeninputServerObserver::NewL(this,srvThreadId);
+TRAP_IGNORE(iObserver = CPeninputServerObserver::NewL(this,srvThreadId));
 }
+}
-TFindThread findPeninputServer( _L("*peninputserver*") );
+TBool RPeninputServerImpl::ServerReady()
-TFullName name;
+	{
-if (findPeninputServer.Next( name ) == KErrNone)
+	return iServerReady;
-{
+	}
-// if server is already running return immediately
-//return KErrAlreadyExists;
-RThread p;
-TInt r = p.Open(name);
-p.Close();
-}
-return error;
-}
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::Version
 // ---------------------------------------------------------------------------
 //
 }
 if(aFlag)
 {
 //show the background control
-if(!iBackgroundCtrl)
+if(!iBackgroundCtrl && bmpHandle != -1)
 {
 iBackgroundCtrl = CPenUiBackgroundWnd::NewL(CCoeEnv::Static()->RootWin(),bmpHandle);
 }
 if(iBackgroundCtrl)
 iBackgroundCtrl->Show(extend, iGlobalNotes,
-iInternalPopup,priority, iResourceChange);
+iInternalPopup,priority, iResourceChange, iDataQueryIsPopped);
 }
 else //undim the window
 {
 if(iBackgroundCtrl)
-iBackgroundCtrl->Hide();
+#ifdef FIX_FOR_NGA
+{
+delete iBackgroundCtrl;
+iBackgroundCtrl = 0;
+}
+#else
+{
+iBackgroundCtrl->Hide();
+}
+#endif
 }
 }
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::ActivateLayout
 // Activate/Deactivate a ui layout
 // ---------------------------------------------------------------------------
 // RPeninputServerImpl::IsDimmed
 // ---------------------------------------------------------------------------
 //
-TInt RPeninputServerImpl::SupportInputMode()
+TInt RPeninputServerImpl::SupportInputMode( TInt aLanguage )
 {
 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;
-//User::WaitForRequest(status);
+TRequestStatus status;
+server.Rendezvous(status);
-iObserver = CPeninputServerObserver::NewL(this,
-0);
-server.Rendezvous(iObserver->RequestStatus());
 server.Resume();
 server.Close();
-iWaitScheduler = CPeninputServerWaiter::NewL();
+User::WaitForRequest(status);
-iWaitScheduler->Start();
+if(ESignalServerReady != status.Int())
-ret = iWaitScheduler->Error();
+ret = KErrGeneral;
+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 aInternal, TInt aPriority, TBool aResource, TBool aDataQueryPopped)
 {
 //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,
+// it will make the backgourd screen black purely.
+if( aDataQueryPopped )
+	{
+Window().SetFaded(ETrue,RWindowTreeNode::EFadeWindowOnly);
+	}
+}
+else
+{
 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 21	ecbabf52600f
parent 20	ebd48d2de13c
child 22	bd83ceabce89