Flipdot-display/src/esp32/logic/display_controller.cpp

#include "logic/display_controller.h"

#include "config.h"
#include "logic/schedule.h"

DisplayController::DisplayController(DisplayPower &power, Frames &frames) : _power(power), _frames(frames)
{
}

void DisplayController::setSettings(const ScheduleSettings &schedule, const ClockSettings &clock)
{
	_schedule = schedule;
	_clock = clock;
	_content_revision++; // e.g. evening time changed: redraw
}

void DisplayController::setEffectTime(uint32_t ms)
{
	_effect_time = ms;
}

void DisplayController::setPage(Page page)
{
	_page = page;
	_content_revision++;
}

void DisplayController::pageChanged()
{
	_content_revision++;
}

void DisplayController::showLive(uint32_t now)
{
	_live = true;
	_live_since = now;
	_content_revision++;
}

void DisplayController::stopLive()
{
	_live = false;
	_content_revision++;
}

bool DisplayController::liveActive() const
{
	return _live;
}

void DisplayController::setPowerEnabled(bool enabled)
{
	_power_enabled = enabled;
}

bool DisplayController::powerEnabled() const
{
	return _power_enabled;
}

void DisplayController::update(uint32_t now, bool time_valid, int hour, int minute, bool wifi_connected)
{
	if (wifi_connected)
		_wifi_lost = false;
	else if (!_wifi_lost)
	{
		_wifi_lost = true;
		_wifi_lost_since = now;
	}
	bool show_no_wifi = _clock.no_wifi_screen && _wifi_lost && now - _wifi_lost_since >= NO_WIFI_SHOW_TIME;

	if (_live && now - _live_since >= LIVE_TIMEOUT)
		stopLive();

	// Switched off elsewhere (power timer, Nano flashing): the Nano lost its frame
	if (!_power.isOn())
		_screen = Screen::Unknown;

	if (_off_timer.expired(now))
	{
		_power.off();
		_screen = Screen::Unknown;
		return;
	}

	if (!_power_enabled)
	{
		if (_power.isOn())
		{
			_showOnce(Screen::Off);
			_off_timer.request(now, CLEAR_BEFORE_OFF_TIME + _effect_time);
		}
		return;
	}

	// Live mode from the web UI: shown right away, whatever the time
	if (_live)
	{
		_off_timer.cancel();
		_ensureOn();
		_showOnce(Screen::Live);
		return;
	}

	// Keep the boot screen until the time is known
	if (!time_valid)
		return;

	switch (scheduleFor(hour, minute, _schedule))
	{
	case ScheduleMode::Night:
		if (_power.isOn())
		{
			_showOnce(Screen::Off);
			_off_timer.request(now, POWER_OFF_DELAY);
		}
		break;
	case ScheduleMode::Clock:
		_off_timer.cancel();
		_ensureOn();
		if (_page == Page::Clock)
			_showClock(hour, minute, show_no_wifi);
		else
			_showOnce(Screen::Page);
		break;
	case ScheduleMode::Standby:
		// Flipdots keep their image without power, so the last image stays visible
		if (_power.isOn())
			_off_timer.request(now, POWER_OFF_DELAY);
		break;
	}
}

void DisplayController::_ensureOn()
{
	if (_power.isOn())
		return;
	_power.on();
	_screen = Screen::Unknown;
}

void DisplayController::_showClock(int hour, int minute, bool no_wifi)
{
	Screen screen = no_wifi ? Screen::NoWifi : Screen::Clock;
	bool evening = isEvening(hour, minute, _clock);
	if (_screen == screen && _shown_hour == hour && _shown_minute == minute && _shown_evening == evening &&
		_shown_revision == _content_revision)
		return;
	if (no_wifi)
		_frames.noWifi(hour, minute);
	else
		_frames.clock(hour, minute, evening);
	_screen = screen;
	_shown_hour = hour;
	_shown_minute = minute;
	_shown_evening = evening;
	_shown_revision = _content_revision;
}

// Screens without the time: only sent again when they or their content changed
void DisplayController::_showOnce(Screen screen)
{
	if (_screen == screen && _shown_revision == _content_revision)
		return;
	switch (screen)
	{
	case Screen::Page:
		_frames.page();
		break;
	case Screen::Live:
		_frames.live();
		break;
	default:
		_frames.off();
		break;
	}
	_screen = screen;
	_shown_revision = _content_revision;
}