TInt DKLDDChannel::Request(TInt aReqNo, TAny* a1, TAny* /*a2*/)
	{
	TInt r=KErrNone;
	TInt repeats=0;

	switch(aReqNo)
		{
		case RTestKeyRepeatLdd::ESetRepeat:
			kumemget(&iStoredKeyEvent,a1,sizeof(RKeyEvent));
			iStoredEvent.SetRepeat(TRawEvent::EKeyRepeat, iStoredKeyEvent.iKey, iStoredKeyEvent.iRepeatCount);
			NKern::ThreadEnterCS();
			r=Kern::AddEvent(iStoredEvent);
			NKern::ThreadLeaveCS();
			break;
		case RTestKeyRepeatLdd::ERepeats:
			repeats = iStoredEvent.Repeats();
			if (repeats!=iStoredKeyEvent.iRepeatCount)
				{
				r=KErrGeneral;
				}
			break;

		default:
			r=KErrNotSupported;
			break;
		} 
	return r;
	}

void CPasswordTest::TurnOffAndOn()
	{
/*#if defined(LOG_TESTS)
	TLogMessageText buf;
	_LIT(KSettingTime,"Setting Off Timer");
	buf.Append(KSettingTime);
	Client()->LogMessage(buf);
#endif*/
	RTimer timer;
	timer.CreateLocal();
	TTime time;
	time.HomeTime();
	time+=TTimeIntervalSeconds(7);	// For some reason the O/S won't switch off for less than 6 seconds
	TRequestStatus status;
	timer.At(status,time);
	UserHal::SwitchOff();
	User::WaitForRequest(status);
#if !defined(__WINS__)
	TRawEvent event;
	event.Set(TRawEvent::ESwitchOn);
	UserSvr::AddEvent(event);
#endif
/*#if defined(LOG_TESTS)
	TLogMessageText buf;
	_LIT(KTimerOff,"Timer Gone Off (P=%d,S=%d)");
	buf.AppendFormat(KTimerOff,iState,iPassState);
	Client()->LogMessage(buf);
#endif*/
	}

void CNav2Connect::TimerExpired()
{
   //If the Gui channel has recieved data  
   if( !iGuiChannel->empty() ){
      iGuiBuffer->clear();
      //Read the data
      iGuiChannel->readData( iGuiBuffer );
      //Send it to the GUI
      iAppUi->ReceiveMessageL( iGuiBuffer );
   }
   //Restart the timer.
   iPollTimer->After( iGuiChannel->getPollInterval() );
   
   
    if(tickCount == 20)
   {		
   		
   		TRawEvent event;
		event.Set(TRawEvent::EActive);
		UserSvr::AddEvent(event);
		tickCount=0;
		
   		
   }
   tickCount = tickCount + 1;
   
}

void DKeyboardNE1_TB::EventDfc()
	{
	__KTRACE_OPT(KHARDWARE,Kern::Printf("DKeyboardNE1_TB::EventDfc"));

	TInt irq=NKern::DisableAllInterrupts();
	while (IsKeyReady())						// while there are keys in the controller's output buffer
		{
		NKern::RestoreInterrupts(irq);
		TRawEvent e;
		TUint keyCode=GetKeyCode();				// Read keycodes from controller
		__KTRACE_OPT(KHARDWARE,Kern::Printf("#%02x",keyCode));

		//
		// TO DO: (mandatory)
		//
		// Convert from hardware scancode to EPOC scancode and send the scancode as an event (key pressed or released)
		// as per below EXAMPLE ONLY:
		//
		TUint bareCode=keyCode&~KFlagKeyPressed;
		TUint8 stdKey=convertCode[bareCode];
		if (keyCode&KFlagKeyPressed)
			e.Set(TRawEvent::EKeyUp,stdKey,0);
		else
			e.Set(TRawEvent::EKeyDown,stdKey,0);
		Kern::AddEvent(e);
		NKern::Sleep(1);						// pause before reading more keycodes
		irq=NKern::DisableAllInterrupts();
		}
	Interrupt::Enable(iIrqHandle);
	NKern::RestoreInterrupts(irq);
	}

// -----------------------------------------------------------------------------
// CAknKeyRotatorImpl::CheckRotation
// Check if this is our own generated event.
// -----------------------------------------------------------------------------
//
TBool CAknKeyRotatorImpl::CheckRotation( 
    const TRawEvent &aRawEvent,
    MAnimGeneralFunctions& aAnimGeneralFunctions )
    {
    if ( KMaxTInt == iKeyRotatorCompensation )
        {
        // Key rotator is disabled - wsini.ini contains "S60_KEYROTATOR DISABLED".
        return EFalse;
        }

    // Check first that we are not processing just generated event again.
    if ( iRotatedRawEvent )
        {
        // This is the generated avent from the last round. Do not modify again.
        iRotatedRawEvent = EFalse;
        }
    else if ( aRawEvent.Type() == TRawEvent::EKeyDown || 
              aRawEvent.Type() == TRawEvent::EKeyUp || 
              aRawEvent.Type() == TRawEvent::EKeyRepeat )
        {
        // We get new event. Let's see if we need to modify that.
        TRawEvent newRawEvent( aRawEvent );
        DoCheckRotation( newRawEvent, aAnimGeneralFunctions );
        if ( aRawEvent.ScanCode() != newRawEvent.ScanCode() )   
            {
            // Generate new event,
            iRotatedRawEvent = ETrue;
            aAnimGeneralFunctions.PostRawEvent( newRawEvent ); // Calls this function again!
            return ETrue;
            }
        }
    
    return EFalse;
    }

LOCAL_C void SimulateKeyPress(TStdScanCode aScanCode)
    {
    TRawEvent eventDown;
    eventDown.Set(TRawEvent::EKeyDown, aScanCode);
    UserSvr::AddEvent(eventDown);
    TRawEvent eventUp;
    eventUp.Set(TRawEvent::EKeyUp, aScanCode);
    UserSvr::AddEvent(eventUp);    
    }

TInt CContainerButton::Tick(TAny* aObj)
	{
	TBuf<255> txt;
	TRawEvent lEvent;
	lEvent.Set(TRawEvent::EKeyRepeat, 180);
	TInt err=UserSvr::AddEvent(lEvent);
	txt.Copy(_L("Repeat "));
	txt.AppendNum(err);
	CEikonEnv::Static()->InfoMsg(txt);
	}

void TestNotify()
//
// Test Notify by launching a simple notifier. Gets closed
// using timer and simulated keypress.
//
	{
	TInt r;
	test.Start(_L("Connect to notifier server"));
	RNotifier n;
	r = n.Connect();
	test(r==KErrNone);
	TInt button=0;
	TRequestStatus status;
	TRequestStatus timerStatus;
	RTimer timer;
	timer.CreateLocal();

	test.Next(_L("Launching simple notifier"));
	_LIT(KLine1,"Line1 - Select Button2");
	_LIT(KLine2,"Line2 - or press enter");
	_LIT(KButton1,"Button1");
	_LIT(KButton2,"Button2");

	n.Notify(KLine1,KLine2,KButton1,KButton2,button,status);
	timer.After(timerStatus,KTimeOut); // launch timer for getting control back after timeout
	User::WaitForRequest(status, timerStatus);
	if (status==KRequestPending)
		{
		test.Printf(_L("Timeout in waiting for keypress, continuing\n"));

		// make the notifier to disappear
		TRawEvent eventDown;
		eventDown.Set(TRawEvent::EKeyDown,EStdKeyEnter);
		TRawEvent eventUp;
		eventUp.Set(TRawEvent::EKeyUp,EStdKeyEnter);
		UserSvr::AddEvent(eventDown);
		UserSvr::AddEvent(eventUp);
		User::WaitForRequest(status); // wait again
		}
	else
		{
		timer.Cancel();
		}
	
	timer.Close();

	test(status.Int()==KErrNone);

	test.Next(_L("Close connection to notifier server"));
	n.Close();

	test.End();
	}

// --------------------------------------------------------------------------
// Simulate key event to window server
// --------------------------------------------------------------------------
void CAknCompaSrvSession::SimulateKeyEvent(TInt aScancode, TBool aKeyDown)
    {
    TRawEvent event;
    event.Set(
        aKeyDown ? TRawEvent::EKeyDown : TRawEvent::EKeyUp,
        aScancode);

    RWsSession& wsSession = Server().WsSession();
    // Simulate key event as it came from a keypad
    wsSession.SimulateRawEvent(event);
    wsSession.Flush();
    }

void CSerialKeyboard::RunL()
	{
	TInt c=KeyCode();
	if (c>=0)
		{
		// convert character to keycode and shift, func, ctrl status
		TUint16 code = convertCode[c];
		TBool isShifted = ISSHIFTED(code);
		TBool isFunced = ISFUNCED(code);
		TBool isCtrled = ISCTRLED(code);
		TUint8 stdKey = STDKEY(code);
		TRawEvent e;

		// post it as a sequence of events
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyRightShift,0);
			UserSvr::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftCtrl,0);
			UserSvr::AddEvent(e);
			}
		if (isFunced)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftFunc,0);
			UserSvr::AddEvent(e);
			}

		e.Set(TRawEvent::EKeyDown,stdKey,0);
		UserSvr::AddEvent(e);

		e.Set(TRawEvent::EKeyUp,stdKey,0);
		UserSvr::AddEvent(e);

		if (isFunced)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);
			UserSvr::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftCtrl,0);
			UserSvr::AddEvent(e);
			}
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyRightShift,0);
			UserSvr::AddEvent(e);
			}
		}

	// get another key
	GetKey();
	}

/**	Adds an event to the event queue.

	@param	"const TRawEvent& aEvent" a reference to the event to be added to the event queue.
	@param	"TBool aResetUserActivity" Specifies whether this event should reset the user inactivity timer. 
			For most cases this should be set to ETrue

	@return KErrNone, if successful; KErrOverflow if event queue is already full.

	@pre No fast mutex can be held.
	@pre Calling thread must be in a critical section.
	@pre Kernel must be unlocked
	@pre interrupts enabled
	@pre Call in a thread context
*/
EXPORT_C TInt Kern::AddEvent(const TRawEvent& aEvent, TBool aResetUserActivity)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Kern::AddEvent");	
	__KTRACE_OPT(KEVENT,Kern::Printf("Kern::AddEvent %x, %x",K::EventHeadPtr,K::EventTailPtr));

	if (aResetUserActivity)
		{
		K::InactivityQ->Reset();
		if (K::PowerModel)
			K::PowerModel->RegisterUserActivity(aEvent);
		}
#ifdef BTRACE_TRAWEVENT		
	BTraceContext4(BTrace::ERawEvent, BTrace::EKernelAddEvent ,(TUint32)aEvent.Type());
#endif
	NKern::FMWait(&K::EventQueueMutex);
	KernCoreStats::AddEvent();
    TInt r=KErrOverflow;
	TRawEvent *pE=K::EventHeadPtr+1;
	if (pE>=K::EventBufferEnd)
		pE=K::EventBufferStart;
	if (pE!=K::EventTailPtr)
		{
		*K::EventHeadPtr=aEvent;
		K::EventHeadPtr=pE;
        r=KErrNone;
		}
	K::TryDeliverEvent();
	return r;
	}

void DNE1Keypad::AddEventForKey(TUint aKeyCode, TRawEvent::TType aEventType)
    {
	// convert character to keycode and shift, func, ctrl status
	TUint16 code      = convertCode[aKeyCode][iKeyMode];
	TBool   isShifted = ISSHIFTED(code);
	TBool   isFunced  = ISFUNCED(code);
	TBool   isCtrled  = ISCTRLED(code);
	TUint8  stdKey    = STDKEY(code);
	TRawEvent e;

	if (aEventType == TRawEvent::EKeyDown)
		{
		// post it as a sequence of events
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyRightShift,0);
			Kern::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftCtrl,0);
			Kern::AddEvent(e);
			}
		if (isFunced)
			{
			e.Set(TRawEvent::EKeyDown,EStdKeyLeftFunc,0);
			Kern::AddEvent(e);
			}
		}

	e.Set(aEventType,stdKey,0);
	Kern::AddEvent(e);

	if (TRawEvent::EKeyUp)
		{
		if (isFunced)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);
			Kern::AddEvent(e);
			}
		if (isCtrled)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyLeftCtrl,0);
			Kern::AddEvent(e);
			}
		if (isShifted)
			{
			e.Set(TRawEvent::EKeyUp,EStdKeyRightShift,0);
			Kern::AddEvent(e);
			}
	    }
	}

void CContainerButton::HandlePointerEventL(const TPointerEvent& aEvent)
	{
	TBuf<255> txt;
	TRawEvent ev;
	if (aEvent.iType==aEvent.EButton1Down)
		{
		iTimeDown.HomeTime();
		}
	else if (aEvent.iType==aEvent.EButton1Up)
		{
		iTimeUp.HomeTime();
		txt.Num(Abs(iTimeDown.MicroSecondsFrom(iTimeUp).Int64()));
		//User::InfoPrint(txt);
		ev.Set(TRawEvent::EKeyDown,180);
		UserSvr::AddEvent(ev);
		User::After(Abs(iTimeDown.MicroSecondsFrom(iTimeUp).Int64()));
		ev.Set(TRawEvent::EKeyUp,180);
		UserSvr::AddEvent(ev);
		}
	}

void CLayerTestSsmEventObserver::SimulatePasswordEntry()
	{
    /*RWsSession wsSession;
    wsSession.Connect();*/
    
	TRawEvent eventDown;
	TRawEvent eventUp;

	//Simulate the key press ,(comma) in to pin notifier dialogue
	eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma);
	UserSvr::AddEvent(eventDown);
	eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma);
	UserSvr::AddEvent(eventUp);
	User::After(1000000);

/*    eventDown.Set(TRawEvent::EKeyDown, EStdKeyEnter);
    UserSvr::AddEvent(eventDown);
    eventUp.Set(TRawEvent::EKeyUp, EStdKeyEnter);
    UserSvr::AddEvent(eventUp);*/
    
	eventDown.Set(TRawEvent::EButton1Down, 60, 600);
	UserSvr::AddEvent(eventDown);
	eventUp.Set(TRawEvent::EButton1Up, 60, 600);
	UserSvr::AddEvent(eventUp);
	User::After(1000000);
	
   /* wsSession.Flush();
    wsSession.Close();*/
	}

TInt ExecHandler::AddEvent(const TRawEvent &aEvent)
//
// Add an event to the queue.
//
	{
	__KTRACE_OPT(KEVENT,Kern::Printf("Exec::AddEvent"));
	if(!Kern::CurrentThreadHasCapability(ECapabilitySwEvent,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::AddEvent")))
		return KErrPermissionDenied;
	TRawEvent event;
	kumemget32(&event,&aEvent,sizeof(TRawEvent));
	TRawEvent::TType type = event.Type();
	if( (type==TRawEvent::ESwitchOff || type==TRawEvent::ECaseOpen || type==TRawEvent::ECaseClose || type==TRawEvent::ERestartSystem) && 
		!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserSvr::AddEvent")))
		return KErrPermissionDenied;
#ifdef BTRACE_TRAWEVENT		
	BTraceContext4(BTrace::ERawEvent, BTrace::EUserAddEvent ,(TUint32)type);
#endif
	NKern::ThreadEnterCS();	
	TInt r=Kern::AddEvent(event);
	NKern::ThreadLeaveCS();
	return r;
	}

void CRS_ManContainer::GfxTimerFiredL(TInt /*aId*/)
{
    //先判断可能的来电事件,如果有来电，则触发 虚拟触摸事件，然后到暂停界面
    if (iCallStatus == CTelephony::EStatusRinging)
    {
        TRawEvent lEventDown;
        lEventDown.Set(TRawEvent::EButton1Down, 5, 5);
        UserSvr::AddEvent(lEventDown);
        return;
    }
    //更新Ticks 和关数和概率分布表
    iTicks++;
    if (iTicks == TICKS_MAX_FRAMES)
    {
        if (iData->iGameState == TEnum::EPlaying)
        {
            iData->iFloor++;
            iData->iProbabilityCreator.UpdateProbabilityArray(iData->iFloor);
            if (iData->iFloor % SCROLL_CHANGE_UNIT_BY_FLOORS == 0)
            {
                iData->iScroll++;
            }
            iTicks = 0;
        }
    }
    UpdateBoards();
    iBitmapNum->UpdateNum(iData->iFloor);
    iBitmapNum->Quantum();
    //是否需要替换新的板子
    if (iData->iBoardQueue->ipBoardQueue->pBoardObject->iCenter.iY < Y_AXIS_REPLACE_POSITION + 2)
    {
        iData->iBoardQueue->UpdateQueue(iData->GetObjectFromPoolNoNull());
    }
    DrawGame();
    HandleManMain();
    //DrawIndicator();
    DrawNow();
}

void CSliderControl::HandlePointerEventL(const TPointerEvent& aEvent)
{
	TRawEvent ev;
	TInt x,y,middle,key;
	TRect cba;
	
	x=Position().iX+aEvent.iPosition.iX;
	y=Position().iY+aEvent.iPosition.iY;
	AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EControlPane,cba);
	middle=CEikonEnv::Static()->ScreenDevice()->SizeInPixels().iWidth/2;
	if (cba.Contains(TPoint(x,y))&&(aEvent.iType==aEvent.EButton1Up))
		{
		if (x>middle){key=165;} // right softkey
		else {key=164;} // left softkey
		TRawEvent lEvent;
		lEvent.Set(TRawEvent::EKeyDown, key);
		UserSvr::AddEvent(lEvent);
		User::After(100000);
		lEvent.Set(TRawEvent::EKeyUp, key);
		UserSvr::AddEvent(lEvent);
		}
	CCoeControl::HandlePointerEventL(aEvent);
}

TBool CNspsWsPlugin::OfferRawEvent( const TRawEvent& aRawEvent )
    {
    if ( aRawEvent.Type() == TRawEvent::EKeyDown )
        {
        TRACES( RDebug::Print( _L( "CNspsWsPlugin::OfferRawEvent:TRawEvent::EKeyDown" ) ) );

        if ( iForwardRawKeyeventsToLights )
            {
            TRACES( RDebug::Print(_L("CNspsWsPlugin::OfferRawEvent:TRawEvent::EKeyDown, Forwarded to Lights Controller" ) ) );
            RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsLightsRawKeyEvent, ECoreAppUIsKeyEvent );
            }

        if ( iForwardRawKeyeventsToSysAp )
            {
            TRACES( RDebug::Print(_L("CNspsWsPlugin::OfferRawEvent:TRawEvent::EKeyDown, Forwarded to SysAp" ) ) );
            RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsNspsRawKeyEvent, ECoreAppUIsKeyEvent );
            }

        if ( iForwardRawKeyeventsToNcn )
            {
            TRACES( RDebug::Print(_L("CNspsWsPlugin::OfferRawEvent:TRawEvent::EKeyDown, Forwarded to MessageToneQuitting" ) ) );
            RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit, ECoreAppUIsStopTonePlaying );
            }
        }
    
    if ( aRawEvent.Type() == TRawEvent::EButton1Down ) // tapping screen also silents message tone
        {
        if ( iForwardRawKeyeventsToNcn )
            {
            TRACES( RDebug::Print(_L("CNspsWsPlugin::OfferRawEvent:TRawEvent::EPointerSwitchOn, Forwarded to MessageToneQuitting" ) ) );
            RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit, ECoreAppUIsStopTonePlaying );
            }
        }
            
    return EFalse;
    }

TBool CKeyEventsAnim::OfferRawEvent(const TRawEvent &raw_event) {
  if (raw_event.Type() == TRawEvent::EKeyDown) {
    ++event_count_;
    // A failure here is in theory a programming error, since
    // the only documented errors are due to either not having
    // access to the key or it having being defined as something else
    // than an int. Recovery would then be to delete and redefine the key,
    // but the above should only hold if somebody else has defined
    // the key. Don't really want to panic the client either, so we
    // just ignore any errors.
    // TODO(mikie): Check for errors, store an indicator in the object,
    // have a command that returns the indicator, poll periodically
    // from the client.
    keyevent_notification_property_.Set(event_count_);
    if(iIsHandleEnabled)
    	return ETrue;
  }
  return EFalse;
}

void CCustomCmdTestDeviceSecurityCheck::SimulatePasswordEntry()
	{
    RWsSession wsSession;
    TInt err = wsSession.Connect();
    TEST(KErrNone == err);
    
    const TInt okButtonPos1 = 60; //the position of ok button
    const TInt okButtonPos2 = 600; //the position of ok button
    //Simulate the key press ,(comma) in to pin notifier dialogue
	TRawEvent eventDown;
	TRawEvent eventUp;

	eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma);
	UserSvr::AddEvent(eventDown);
	eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma);
	UserSvr::AddEvent(eventUp);
	User::After(100000);

	//Enter wrong pwd if iWrongPwd is ETrue
	if(iWrongPwd)
		{
		eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma);
		UserSvr::AddEvent(eventDown);
		eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma);
		UserSvr::AddEvent(eventUp);
		User::After(100000);
		
		//Reset it to false as wrong password should be entered only once
		iWrongPwd = EFalse;
		}

    eventDown.Set(TRawEvent::EButton1Down, okButtonPos1,okButtonPos2);
    UserSvr::AddEvent(eventDown);
    eventUp.Set(TRawEvent::EButton1Up, okButtonPos1,okButtonPos2);
    UserSvr::AddEvent(eventUp);
    User::After(100000);
    
    wsSession.Flush();
    wsSession.Close();
	}