MuditaOS/module-gui/gui/widgets/TopBar.cpp

/*
 * @file TopBar.cpp
 * @author Robert Borzecki (robert.borzecki@mudita.com)
 * @date 22 cze 2019
 * @brief
 * @copyright Copyright (C) 2019 mudita.com
 * @details
 */

#include <ctime>
#include <iomanip>
#include "Label.hpp"
#include "Image.hpp"
#include "TopBar.hpp"
#include <time/time_conversion.hpp>
#include "Style.hpp"

#include "common_data/EventStore.hpp"

namespace gui {

    const uint32_t TopBar::signalOffset = 35;
    const uint32_t TopBar::batteryOffset = 415;
    gui::TopBar::TimeMode TopBar::timeMode = TimeMode::TIME_24H;
    uint32_t TopBar::time = 0;

    TopBar::TopBar()
    {

        prepareWidget();

        setFillColor(ColorFullWhite);
        setBorderColor(ColorNoColor);
        setFilled(true);
        setSize(480, 50);
}
TopBar::TopBar( Item* parent, uint32_t x, uint32_t y, uint32_t w, uint32_t h ) : Rect{ parent, x, y, w, h } {

	prepareWidget();

	setFillColor( ColorFullWhite );
	setBorderColor( ColorNoColor );
	setFilled(true);
	setSize(480, 50);
	updateDrawArea();
}
TopBar::~TopBar() {
}

void TopBar::batteryShowBars(uint32_t val)
{
    int i = 0;
    if (val > battery.size())
    {
        LOG_ERROR("Trying to set battery level out of scope");
        val = battery.size();
    }
    for (int i = 0; i < battery.size(); ++i)
    {
        battery[i]->setVisible(val > i);
    }
}

void TopBar::prepareWidget() {

	signal[0] = new gui::Image( this, signalOffset,17,0,0, "signal0" );
	signal[1] = new gui::Image( this, signalOffset,17,0,0, "signal1" );
	signal[2] = new gui::Image( this, signalOffset,17,0,0, "signal2" );
	signal[3] = new gui::Image( this, signalOffset,17,0,0, "signal3" );
	signal[4] = new gui::Image( this, signalOffset,17,0,0, "signal4" );
	signal[5] = new gui::Image( this, signalOffset,17,0,0, "signal5" );
    updateSignalStrength();

    //icons for battery
    battery = {
        new gui::Image(this, batteryOffset, 17, 0, 0, "battery0"), new gui::Image(this, batteryOffset, 17, 0, 0, "battery1"),
        new gui::Image(this, batteryOffset, 17, 0, 0, "battery2"), new gui::Image(this, batteryOffset, 17, 0, 0, "battery3"),
        new gui::Image(this, batteryOffset, 17, 0, 0, "battery4"), new gui::Image(this, batteryOffset, 17, 0, 0, "battery5"),
    };
    batteryShowBars(0);

    charging = new Label(this, batteryOffset, 17, 30, this->drawArea.h);
    charging->setFilled(false);
    charging->setBorderColor(gui::ColorNoColor);
    charging->setFont(style::header::font::title);
    charging->setText("Z");
    charging->setVisible(false);

    const auto design_sim_offset = 378; // this offset is not final
    sim = new SIM(this, design_sim_offset, 17);

    //icon of the lock
	lock = new gui::Image( this, 240-11,17,0,0, "lock" );

	//time label
	timeLabel = new Label(this, 0, 0, 480, this->drawArea.h );
	timeLabel->setFilled( false );
	timeLabel->setBorderColor( gui::ColorNoColor );
	timeLabel->setFont(style::header::font::time);
	timeLabel->setText("00:00");
	timeLabel->setAlignement( gui::Alignment(gui::Alignment::ALIGN_HORIZONTAL_CENTER, gui::Alignment::ALIGN_VERTICAL_CENTER));
}

void TopBar::setActive(std::list<std::pair<TopBar::Elements, bool>> elements)
{
    for (auto el : elements)
    {
        setActive(el.first, el.second);
    }
}

void TopBar::setActive( TopBar::Elements element, bool active ) {
	switch( element ) {
		case Elements::BATTERY: {
            elements.battery = active;
            if (Store::Battery::get().state == Store::Battery::State::Discharging)
            {
                setBatteryLevel(active ? Store::Battery::get().level : 0);
            }
            else
            {
                if (active)
                {
                    setBatteryCharging(true);
                }
                else
                {
                    charging->setVisible(false);
                    setBatteryLevel(0);
                }
            }
        } break;
		case Elements::LOCK: {
            elements.lock = active;
            lock->setVisible(active);
			if( active )
				timeLabel->setVisible(false);
		} break;
		case Elements::SIGNAL: {
            elements.signal = active;
            updateSignalStrength();
        } break;
		case Elements::TIME: {
            elements.time = active;
            timeLabel->setVisible(active);
			if( active )
				lock->setVisible(false);
		} break;
        case Elements::SIM:
            elements.sim = active;
            simSet();
            break;
    };
}

uint32_t calculateBatteryLavel(uint32_t percentage)
{
    uint32_t level = 0;
    if (percentage <= 5)
        level = 0;
    else if (percentage <= 27)
        level = 1;
    else if (percentage <= 50)
        level = 2;
    else if (percentage <= 73)
        level = 3;
    else if (percentage <= 95)
        level = 4;
    else
        level = 5;

    if (level >= batteryLevelCount)
    {
        LOG_ERROR("Battery level calculations are done wrong!");
        return batteryLevelCount - 1;
    }
    return level;
}

bool TopBar::setBatteryLevel(uint32_t percent)
{
    if (Store::Battery::get().state != Store::Battery::State::Discharging)
    {
        return false;
    }
    charging->setVisible(false);
    batteryShowBars(calculateBatteryLavel(percent));
    return true;
}

void TopBar::setBatteryCharging(bool plugged)
{
    if (plugged)
    {
        batteryShowBars(0);
    }
    if (charging == nullptr)
        return;
    if (plugged)
    {
        charging->setVisible(true);
        batteryShowBars(0);
    }
    else
    {
        charging->setVisible(false);
        setBatteryLevel(Store::Battery::get().level);
    }
}

bool TopBar::updateSignalStrength()
{
    for (uint32_t i = 0; i < signalImgCount; i++)
    {
        signal[i]->setVisible(false);
    }
    if (elements.signal)
    {
        auto rssiBar = Store::GSM::get()->getSignalStrength().rssiBar;
        if (rssiBar < Store::RssiBar::noOfSupprtedBars)
        {
            signal[static_cast<size_t>(rssiBar)]->setVisible(true);
            return true;
        }
        return false;
    }
    return true;
}

void TopBar::setTime( const UTF8& time ) {
	timeLabel->setText(time);
}

void TopBar::setTime( const uint32_t& time, bool mode24H ) {

	std::time_t t= time;
    setTime(utils::time::Time());

    timeMode = (mode24H ? TimeMode::TIME_24H : TimeMode::TIME_12H);
    this->time = time;
}

UTF8 TopBar::getTimeString() {
	setTime( time, (timeMode == TimeMode::TIME_24H )?true:false );
	return timeLabel->getText();
}

std::list<DrawCommand*> TopBar::buildDrawList() {

	//make sure that time text is updated.
	setTime( time, (timeMode == TimeMode::TIME_24H )?true:false );

	return Rect::buildDrawList();
}

void TopBar::simSet()
{
    if (!sim)
    {
        return;
    }
    else if (elements.sim)
    {
        return sim->show(Store::GSM::get()->sim);
    }
    sim->visible = false;
}

} /* namespace gui */