src/app/buttoneventslogger.cpp

@@ -9,13 +9,8 @@
 #include "trace/trace.h"
 #include "ButtonEvent.h"
 
-ButtonEventsLogger::ButtonEventsLogger()
+ButtonEventsLogger::ButtonEventsLogger() {
-	: stWait(this) {
+	curentState_ = state::initial;
-
-	stInitial.addInitialTransition(&stWait);
-	stWait.addTransition(event::evButtonShortPressed, &stWait);
-	stWait.addTransition(event::evButtonLongPressed, &stWait);
-	stWait.registerOnEntry((XFState::callbackEv)&ButtonEventsLogger::logOnTrace);
 }
 
 void ButtonEventsLogger::onButtonShortPressed(ButtonIndex buttonIndex) {
@@ -26,13 +21,62 @@ void ButtonEventsLogger::onButtonLongPressed(ButtonIndex buttonIndex) {
 	GEN(ButtonEvent(event::evButtonLongPressed, this, buttonIndex));
 }
 
-void ButtonEventsLogger::logOnTrace(const XFEvent* ev) {
+XFEventStatus ButtonEventsLogger::processEvent() {
-	ButtonEvent* buttonEvent = (ButtonEvent*)ev;
+	eEventStatus eventStatus = XFEventStatus::NotConsumed;
-	int evid = buttonEvent->getId();
+
-	if(evid == event::evButtonShortPressed){
+	ButtonEvent* ev = (ButtonEvent*)getCurrentEvent();
-			Trace::out("ButtonEventLogger: Button %d short pressed", buttonEvent->getButtonId());
+	XFEvent::XFEventType evType = ev->getEventType();
+	int evid = ev->getId();
+
+	oldState_ = curentState_;
+	changeXFState = false;
+
+
+
+	switch (curentState_) { //on state
+		case state::initial:
+			if(evType == XFEvent::Initial) {
+				curentState_ = state::waitButtonPressed;
+				changeXFState = true;
+				eventStatus = XFEventStatus::Consumed;
+			}
+			break;
+
+		case state::waitButtonPressed:
+			if(evid == event::evButtonShortPressed){
+					Trace::out("ButtonEventLogger: Button %d short pressed", ev->getButtonId());
+					curentState_ = state::waitButtonPressed;
+					changeXFState = true;
+					eventStatus = XFEventStatus::Consumed;
+			}
+			if(evid == event::evButtonLongPressed){
+					Trace::out("ButtonEventLogger: Button %d long pressed", ev->getButtonId());
+					curentState_ = state::waitButtonPressed;
+					changeXFState = true;
+					eventStatus = XFEventStatus::Consumed;
+			}
+			break;
 	}
-	if(evid == event::evButtonLongPressed){
+
-			Trace::out("ButtonEventLogger: Button %d long pressed", buttonEvent->getButtonId());
+	if(changeXFState) {
+		switch (oldState_) { // onExit
+			case state::initial:
+				break;
+
+			case state::waitButtonPressed:
+				break;
+		}
+
+		switch (curentState_) { // onEntry
+			case state::initial:
+				break;
+
+			case state::waitButtonPressed:
+				break;
+
+		}
+		changeXFState = false;
 	}
+	return eventStatus;
 }
+

src/app/buttoneventslogger.h

@@ -21,14 +21,20 @@ public:
 
 
 protected:
-	void logOnTrace(const XFEvent* ev);
+	XFEventStatus processEvent() override;
 
 	typedef enum {
-		evButtonShortPressed = 10,
+		evButtonShortPressed = 1,
 		evButtonLongPressed
 	} event;
 
-	XFState stWait;
+	typedef enum {
+		initial,
+		waitButtonPressed
+	} state;
+
+	state curentState_;
+	state oldState_;
 
 };
 

src/mdw/button/ButtonEventsHandler.cpp

@@ -16,12 +16,12 @@ ButtonEventsHandler::ButtonEventsHandler()
 		observer_[i] = nullptr;
 	}
 
-	stInitial.addInitialTransition(&stRun);
+	stInitial.setNextState(&stRun);
 	stRun.registerOnEntry((XFState::callback)&ButtonEventsHandler::startButtonSM);
 
 }
 
-void ButtonEventsHandler::startButtonSM() {
+void ButtonEventsHandler::startButtonSM(const XFEvent* ev) {
 	buttonStateSm_[0].startBehavior();
 	buttonStateSm_[1].startBehavior();
 	buttonStateSm_[2].startBehavior();

src/mdw/button/ButtonEventsHandler.h

@@ -31,7 +31,7 @@ public:
 
 protected:
 	ButtonEventsHandler();
-	void startButtonSM();
+	void startButtonSM(const XFEvent* ev);
 
 	XFState stRun;
 

src/mdw/button/ButtonStateSm.cpp

@@ -8,27 +8,10 @@
 #include <button/ButtonStateSm.h>
 #include "mdw/button/ButtonEventsHandler.h"
 
+//TODO start State Machine. For that, turn ButtonEventsHandler to a State Machine (Initial, run)
 ButtonStateSm::ButtonStateSm()
-	: buttonIndex_(getNbInstance()),
+	: buttonIndex_(getNbInstance()) {
-	  stWaitButtonPressed(this),
+	currentState_ = state::initial;
-	  stButtonPressed(this),
-	  stButtonShortPressed(this),
-	  stButtonLongPressed(this) {
-
-	stInitial.addInitialTransition(&stWaitButtonPressed);
-
-	stWaitButtonPressed.addTransition(event::evButtonPressed, &stButtonPressed);
-
-	// TODO bug if setTimeout is used before addTransition !!!
-	stButtonPressed.addTransition(event::evButtonReleased, &stButtonShortPressed);
-	stButtonPressed.setTimeout(1000, &stButtonLongPressed);
-	stButtonPressed.registerOnExit((XFState::callback)&ButtonStateSm::genNullTransition);
-
-	stButtonShortPressed.registerOnEntry((XFState::callback)&ButtonStateSm::notifyShortPress);
-	stButtonShortPressed.addTransition(event::evReturn, &stWaitButtonPressed);
-
-	stButtonLongPressed.registerOnEntry((XFState::callback)&ButtonStateSm::notifyLongPress);
-	stButtonLongPressed.addTransition(event::evReturn, &stWaitButtonPressed);
 }
 
 uint8_t ButtonStateSm::getNbInstance(){
@@ -43,14 +26,102 @@ void ButtonStateSm::genButtonReleased() {
 	GEN(XFEvent(XFEvent::Event, event::evButtonReleased, this));
 }
 
-void ButtonStateSm::notifyShortPress() {
+XFEventStatus ButtonStateSm::processEvent() {
-	ButtonEventsHandler::getInstance()->notifyButtonShortPressed(buttonIndex_);
+	eEventStatus eventStatus = XFEventStatus::Unknown;
-}
 
-void ButtonStateSm::notifyLongPress() {
+	const XFEvent* ev = getCurrentEvent();
-	ButtonEventsHandler::getInstance()->notifyButtonLongPressed(buttonIndex_);
+	XFEvent::XFEventType evType = ev->getEventType();
-}
+	int evid = ev->getId();
 
-void ButtonStateSm::genNullTransition() {
+	oldState_ = currentState_;
-	GEN(XFEvent(XFEvent::Event, event::evReturn, this));
+	changeState_ = false;
+
+	switch (currentState_) {
+		case state::initial:
+			if(evType == XFEvent::Initial) {
+				currentState_ = state::waitButtonPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+			}
+			break;
+
+		case state::waitButtonPressed:
+			if(evid == event::evButtonPressed) {
+				currentState_ = state::buttonPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+				scheduleTimeout(event::evTimeout, 1000);
+			}
+			break;
+
+		case state::buttonPressed:
+			if(evid == event::evButtonReleased) {
+				currentState_ = state::buttonShortPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+				unscheduleTimeout(event::evTimeout);
+			}
+			if(evid == event::evTimeout) {
+				currentState_ = state::buttonLongPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+			}
+			GEN(XFNullTransition(this));
+			break;
+
+		case state::buttonShortPressed:
+			if(evType == XFEvent::XFEventType::NullTransition) {
+				currentState_ = state::waitButtonPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+			}
+			break;
+
+		case state::buttonLongPressed:
+			if(evType == XFEvent::XFEventType::NullTransition) {
+				currentState_ = state::waitButtonPressed;
+				changeState_ = true;
+				eventStatus = XFEventStatus::Consumed;
+			}
+			break;
+	}
+
+	if(changeState_) {
+		switch (oldState_) { // onExit
+			case state::initial:
+				break;
+
+			case state::waitButtonPressed:
+				break;
+
+			case state::buttonPressed:
+				break;
+
+			case state::buttonShortPressed:
+				break;
+
+			case state::buttonLongPressed:
+				break;
+		}
+
+		switch (currentState_) {
+			case state::initial:
+				break;
+
+			case state::waitButtonPressed:
+				break;
+
+			case state::buttonPressed:
+				break;
+
+			case state::buttonShortPressed:
+				ButtonEventsHandler::getInstance()->notifyButtonShortPressed(buttonIndex_);
+				break;
+
+			case state::buttonLongPressed:
+				ButtonEventsHandler::getInstance()->notifyButtonLongPressed(buttonIndex_);
+				break;
+		}
+	}
+	return eventStatus;
 }

src/mdw/button/ButtonStateSm.h

@@ -18,23 +18,26 @@ public:
 	void genButtonReleased();
 
 protected:
-	void notifyShortPress();
+	XFEventStatus processEvent();
-	void notifyLongPress();
-	void genNullTransition();
 
 	typedef enum {
-		evButtonPressed = 10,
+		evButtonPressed,
 		evButtonReleased,
-		evTimeout,
+		evTimeout
-		evReturn
 	} event;
 
-	const uint8_t buttonIndex_;
+	typedef enum {
+		initial,
+		waitButtonPressed,
+		buttonPressed,
+		buttonShortPressed,
+		buttonLongPressed
+	} state;
 
-	XFState stWaitButtonPressed;
+	state currentState_;
-	XFState stButtonPressed;
+	state oldState_;
-	XFState stButtonShortPressed;
+	bool changeState_;
-	XFState stButtonLongPressed;
+	const uint8_t buttonIndex_;
 
 private:
 	static uint8_t getNbInstance();

src/platform/f7-disco-gcc/board/ButtonsController.cpp

@@ -16,8 +16,8 @@ ButtonsController::ButtonsController()
 	cbProvider = nullptr;
 	cbMethod = nullptr;
 
-	stInitial.addInitialTransition(&stCheckButtons);
+	stInitial.setNextState(&stCheckButtons);
-	stCheckButtons.addTransition(event::evButtonIrq, &stDebounce);
+	stCheckButtons.setNextState(event::evButtonIrq, &stDebounce);
 	stCheckButtons.registerOnEntry((XFState::callback)&ButtonsController::fctCheckButtons);
 
 	stDebounce.setTimeout(20, &stCheckButtons);
@@ -45,7 +45,7 @@ bool ButtonsController::registerCallback(
 	return true;
 }
 
-void ButtonsController::fctCheckButtons() {
+void ButtonsController::fctCheckButtons(const XFEvent* ev) {
 	if(cbProvider != nullptr) {
 
 		newState[0] = HAL_GPIO_ReadPin(BUTTON0_GPIO_Port, BUTTON0_Pin);

src/platform/f7-disco-gcc/board/ButtonsController.h

@@ -30,7 +30,8 @@ protected:
 	bool newState[4];
 	bool buttonState[4];
 
-	void fctCheckButtons();
+	void fctCheckButtons(const XFEvent* ev);
+	void fctScheduleTimeout(const XFEvent* ev);
 
 	XFState stCheckButtons;
 	XFState stDebounce;

src/xf/core/XFState.cpp

@@ -14,15 +14,9 @@
 XFState::XFState(XFBehavior* behavior)
 	: pBehavior(behavior) {
 	assert(behavior != nullptr);
-	cbState_ = nullptr;
-	cbEntry_ = nullptr;
-	cbExit_ = nullptr;
-	cbEvState_ = nullptr;
-	cbEvEntry_ = nullptr;
-	cbEvExit_ = nullptr;
 }
 
-void XFState::addTransition(XFEvent::XFEventType type, const int evid, const int time, XFState* state) {
+void XFState::setNextState(const int evid, const int time, XFEvent::XFEventType type, XFState* state) {
 	assert(state != nullptr);
 	transition t;
 	t.evid = evid;
@@ -34,14 +28,11 @@ void XFState::addTransition(XFEvent::XFEventType type, const int evid, const int
 
 XFEventStatus XFState::onState(const XFEvent* ev) {
 
-	if(cbState_ != nullptr) {
+	assert(ev != nullptr);
-		(pBehavior->*cbState_)();
+	assert(pBehavior != nullptr);
-	}
-	if(cbEvState_ != nullptr) {
-		(pBehavior->*cbEvState_)(ev);
-	}
 
 	for(transition t : transitions_) {
+		assert(t.nextState != nullptr);
 
 		if(t.evType == XFEvent::XFEventType::Initial){
 			pBehavior->curentXFState_ = t.nextState;
@@ -68,14 +59,11 @@ XFEventStatus XFState::onState(const XFEvent* ev) {
 
 void XFState::onEntry(const XFEvent* ev) {
 	if(cbEntry_ != nullptr) {
-		(pBehavior->*cbEntry_)();
+		(pBehavior->*cbEntry_)(ev);
-	}
-
-	if(cbEvEntry_ != nullptr) {
-		(pBehavior->*cbEvEntry_)(ev);
 	}
 
 	for(transition t : transitions_) {
+		assert(t.nextState != nullptr);
 
 		if(t.evType == XFEvent::XFEventType::Timeout) {
 			pBehavior->scheduleTimeout(XFEvent::Timeout, t.time);
@@ -85,19 +73,6 @@ void XFState::onEntry(const XFEvent* ev) {
 }
 void XFState::onExit(const XFEvent* ev) {
 	if(cbExit_ != nullptr) {
-		(pBehavior->*cbExit_)();
+		(pBehavior->*cbExit_)(ev);
-	}
-
-	if(cbEvExit_ != nullptr) {
-		(pBehavior->*cbEvExit_)(ev);
-	}
-
-	for(transition t: transitions_) {
-
-		if(t.evType == XFEvent::XFEventType::Timeout) {
-			if(ev->getEventType() != XFEvent::XFEventType::Timeout) {
-				pBehavior->unscheduleTimeout(XFEvent::Timeout);
-			}
-		}
 	}
 }

src/xf/include/xf/XFState.h

@@ -24,20 +24,17 @@ public:
 	XFState(XFBehavior* behavior);
 	~XFState() = default;
 
-	inline void addTransition(const int evid, XFState* state) { addTransition(XFEvent::XFEventType::Event, evid, 0, state); };
+	inline void setNextState(XFState* state) { setNextState(XFEvent::Initial, XFEvent::XFEventType::Initial, state); };
+	inline void setNextState(const int evid, XFState* state) { setNextState(evid, XFEvent::XFEventType::Event, state); };
 
-	inline void setTimeout(int time, XFState* nextState) { addTransition(XFEvent::XFEventType::Timeout, XFEvent::Timeout, time, nextState); };
+	inline void setTimeout(int time, XFState* nextState) { setNextState(XFEvent::Timeout, time, XFEvent::XFEventType::Timeout, nextState); };
-	typedef void (XFBehavior::*callback)();
+	typedef void (XFBehavior::*callback)(const XFEvent* ev);
-	typedef void (XFBehavior::*callbackEv)(const XFEvent* ev);
-	//inline void registerOnState(callback cbState) { cbState_ = cbState; };
 	inline void registerOnEntry(callback cbEntry) { cbEntry_ = cbEntry; };
 	inline void registerOnExit(callback cbExit) { cbExit_ = cbExit; };
-	//inline void registerOnState(callbackEv cbState) { cbEvState_ = cbState; };
-	inline void registerOnEntry(callbackEv cbEntry) { cbEvEntry_ = cbEntry; };
-	inline void registerOnExit(callbackEv cbExit) { cbEvExit_ = cbExit; };
 
 protected:
-	void addTransition(XFEvent::XFEventType type, const int evid, const int time, XFState* state);
+	inline void setNextState(const int evid, XFEvent::XFEventType type, XFState* state) {setNextState(evid, 0, type, state); };
+	void setNextState(const int evid, const int time, XFEvent::XFEventType type, XFState* state);
 
 	XFEventStatus onState(const XFEvent* ev);
 	void onEntry(const XFEvent* ev);
@@ -53,20 +50,9 @@ protected:
 	} transition;
 	std::list<transition> transitions_;
 
-	callback cbState_;
 	callback cbEntry_;
 	callback cbExit_;
-	callbackEv cbEvState_;
-	callbackEv cbEvEntry_;
-	callbackEv cbEvExit_;
 
 };
 
-
-class XFInitialState : public XFState {
-public:
-	inline XFInitialState(XFBehavior* behavior) : XFState(behavior) {};
-	~XFInitialState() = default;
-	inline void addInitialTransition(XFState* state) { addTransition(XFEvent::XFEventType::Initial, XFEvent::Initial, 0, state); };
-};
 #endif /* XFSTATE_H_ */

src/xf/include/xf/behavior.h

@@ -100,7 +100,7 @@ protected:
     const XFEvent * pCurrentEvent_;					///< Reference to actually processed event.
 
 protected:
-    XFInitialState stInitial;
+    XFState stInitial;
 	XFState* curentXFState_ = &stInitial;
 	XFState* oldXFState_ = &stInitial;
 	bool changeXFState = false;