diff --git a/src/components/ble/MusicService.cpp b/src/components/ble/MusicService.cpp index 9105a8e6..84f2972b 100644 --- a/src/components/ble/MusicService.cpp +++ b/src/components/ble/MusicService.cpp @@ -1,129 +1,225 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ #include #include "MusicService.h" int MSCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) { - auto musicService = static_cast(arg); + auto musicService = static_cast(arg); return musicService->OnCommand(conn_handle, attr_handle, ctxt); } -Pinetime::Controllers::MusicService::MusicService(Pinetime::System::SystemTask &system) : m_system(system) -{ - msUuid.value[11] = msId[0]; - msUuid.value[12] = msId[1]; - msEventCharUuid.value[11] = msEventCharId[0]; - msEventCharUuid.value[12] = msEventCharId[1]; - msStatusCharUuid.value[11] = msStatusCharId[0]; - msStatusCharUuid.value[12] = msStatusCharId[1]; - msTrackCharUuid.value[11] = msTrackCharId[0]; - msTrackCharUuid.value[12] = msTrackCharId[1]; - msArtistCharUuid.value[11] = msArtistCharId[0]; - msArtistCharUuid.value[12] = msArtistCharId[1]; - msAlbumCharUuid.value[11] = msAlbumCharId[0]; - msAlbumCharUuid.value[12] = msAlbumCharId[1]; - - characteristicDefinition[0] = { .uuid = (ble_uuid_t*)(&msEventCharUuid), - .access_cb = MSCallback, - .arg = this, - .flags = BLE_GATT_CHR_F_NOTIFY, - .val_handle = &m_eventHandle - }; - characteristicDefinition[1] = { .uuid = (ble_uuid_t*)(&msStatusCharUuid), - .access_cb = MSCallback, - .arg = this, - .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ - }; - characteristicDefinition[2] = { .uuid = (ble_uuid_t*)(&msTrackCharUuid), - .access_cb = MSCallback, - .arg = this, - .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ - }; - characteristicDefinition[3] = { .uuid = (ble_uuid_t*)(&msArtistCharUuid), - .access_cb = MSCallback, - .arg = this, - .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ - }; - characteristicDefinition[4] = { .uuid = (ble_uuid_t*)(&msAlbumCharUuid), - .access_cb = MSCallback, - .arg = this, - .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ - }; - characteristicDefinition[5] = {0}; - - serviceDefinition[0] = { - .type = BLE_GATT_SVC_TYPE_PRIMARY, - .uuid = (ble_uuid_t *) &msUuid, - .characteristics = characteristicDefinition - }; - serviceDefinition[1] = {0}; - - m_artist = "Waiting for"; - m_album = ""; - m_track = "track information..."; +Pinetime::Controllers::MusicService::MusicService(Pinetime::System::SystemTask &system) : m_system(system) { + msUuid.value[11] = msId[0]; + msUuid.value[12] = msId[1]; + msEventCharUuid.value[11] = msEventCharId[0]; + msEventCharUuid.value[12] = msEventCharId[1]; + msStatusCharUuid.value[11] = msStatusCharId[0]; + msStatusCharUuid.value[12] = msStatusCharId[1]; + msTrackCharUuid.value[11] = msTrackCharId[0]; + msTrackCharUuid.value[12] = msTrackCharId[1]; + msArtistCharUuid.value[11] = msArtistCharId[0]; + msArtistCharUuid.value[12] = msArtistCharId[1]; + msAlbumCharUuid.value[11] = msAlbumCharId[0]; + msAlbumCharUuid.value[12] = msAlbumCharId[1]; + msPositionCharUuid.value[11] = msPositionCharId[0]; + msPositionCharUuid.value[12] = msPositionCharId[1]; + msTotalLengthCharUuid.value[11] = msTotalLengthCharId[0]; + msTotalLengthCharUuid.value[12] = msTotalLengthCharId[1]; + msTrackNumberCharUuid.value[11] = msTrackNumberCharId[0]; + msTrackNumberCharUuid.value[12] = msTrackNumberCharId[1]; + msTrackTotalCharUuid.value[11] = msTrackTotalCharId[0]; + msTrackTotalCharUuid.value[12] = msTrackTotalCharId[1]; + msPlaybackSpeedCharUuid.value[11] = msPlaybackSpeedCharId[0]; + msPlaybackSpeedCharUuid.value[12] = msPlaybackSpeedCharId[1]; + msRepeatCharUuid.value[11] = msRepeatCharId[0]; + msRepeatCharUuid.value[12] = msRepeatCharId[1]; + msShuffleCharUuid.value[11] = msShuffleCharId[0]; + msShuffleCharUuid.value[12] = msShuffleCharId[1]; + + characteristicDefinition[0] = {.uuid = (ble_uuid_t *) (&msEventCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_NOTIFY, + .val_handle = &eventHandle + }; + characteristicDefinition[1] = {.uuid = (ble_uuid_t *) (&msStatusCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[2] = {.uuid = (ble_uuid_t *) (&msTrackCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[3] = {.uuid = (ble_uuid_t *) (&msArtistCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[4] = {.uuid = (ble_uuid_t *) (&msAlbumCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[5] = {.uuid = (ble_uuid_t *) (&msPositionCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[6] = {.uuid = (ble_uuid_t *) (&msTotalLengthCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[7] = {.uuid = (ble_uuid_t *) (&msTotalLengthCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[8] = {.uuid = (ble_uuid_t *) (&msTrackNumberCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[9] = {.uuid = (ble_uuid_t *) (&msTrackTotalCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[10] = {.uuid = (ble_uuid_t *) (&msPlaybackSpeedCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[11] = {.uuid = (ble_uuid_t *) (&msRepeatCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[12] = {.uuid = (ble_uuid_t *) (&msShuffleCharUuid), + .access_cb = MSCallback, + .arg = this, + .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ + }; + characteristicDefinition[13] = {0}; + + serviceDefinition[0] = { + .type = BLE_GATT_SVC_TYPE_PRIMARY, + .uuid = (ble_uuid_t *) &msUuid, + .characteristics = characteristicDefinition + }; + serviceDefinition[1] = {0}; + + artistName = "Waiting for"; + albumName = ""; + trackName = "track information..."; + playing = false; + repeat = false; + shuffle = false; + playbackSpeed = 1.0f; + trackProgress = 0; + trackLength = 0; } -void Pinetime::Controllers::MusicService::Init() -{ +void Pinetime::Controllers::MusicService::Init() { int res = 0; res = ble_gatts_count_cfg(serviceDefinition); ASSERT(res == 0); - + res = ble_gatts_add_svcs(serviceDefinition); ASSERT(res == 0); } int Pinetime::Controllers::MusicService::OnCommand(uint16_t conn_handle, uint16_t attr_handle, - struct ble_gatt_access_ctxt *ctxt) { - + struct ble_gatt_access_ctxt *ctxt) { + if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) { - size_t notifSize = OS_MBUF_PKTLEN(ctxt->om); - uint8_t data[notifSize + 1]; - data[notifSize] = '\0'; - os_mbuf_copydata(ctxt->om, 0, notifSize, data); - char *s = (char *) &data[0]; - NRF_LOG_INFO("DATA : %s", s); - if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msArtistCharUuid) == 0) { - m_artist = s; - } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msTrackCharUuid) == 0) { - m_track = s; - } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msAlbumCharUuid) == 0) { - m_album = s; - } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msStatusCharUuid) == 0) { - m_status = s[0]; - } + size_t notifSize = OS_MBUF_PKTLEN(ctxt->om); + uint8_t data[notifSize + 1]; + data[notifSize] = '\0'; + os_mbuf_copydata(ctxt->om, 0, notifSize, data); + char *s = (char *) &data[0]; + NRF_LOG_INFO("DATA : %s", s); + if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msArtistCharUuid) == 0) { + artistName = s; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msTrackCharUuid) == 0) { + trackName = s; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msAlbumCharUuid) == 0) { + albumName = s; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msStatusCharUuid) == 0) { + playing = s[0]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msRepeatCharUuid) == 0) { + repeat = s[0]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msShuffleCharUuid) == 0) { + shuffle = s[0]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msPositionCharUuid) == 0) { + trackProgress = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msTotalLengthCharUuid) == 0) { + trackLength = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msTrackNumberCharUuid) == 0) { + trackNumber = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msTrackTotalCharUuid) == 0) { + tracksTotal = (s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3]; + } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *) &msPlaybackSpeedCharUuid) == 0) { + playbackSpeed = static_cast(((s[0] << 24) | (s[1] << 16) | (s[2] << 8) | s[3])) / 100.0f; + } } return 0; } -std::string Pinetime::Controllers::MusicService::album() -{ - return m_album; +std::string Pinetime::Controllers::MusicService::getAlbum() { + return albumName; } -std::string Pinetime::Controllers::MusicService::artist() -{ - return m_artist; +std::string Pinetime::Controllers::MusicService::getArtist() { + return artistName; } -std::string Pinetime::Controllers::MusicService::track() -{ - return m_track; +std::string Pinetime::Controllers::MusicService::getTrack() { + return trackName; } -unsigned char Pinetime::Controllers::MusicService::status() -{ - return m_status; +bool Pinetime::Controllers::MusicService::isPlaying() { + return playing; } -void Pinetime::Controllers::MusicService::event(char event) -{ - auto *om = ble_hs_mbuf_from_flat(&event, 1); - - uint16_t connectionHandle = m_system.nimble().connHandle(); - - if (connectionHandle == 0 || connectionHandle == BLE_HS_CONN_HANDLE_NONE) { - return; - } - - ble_gattc_notify_custom(connectionHandle, m_eventHandle, om); +float Pinetime::Controllers::MusicService::getPlaybackSpeed() { + return playbackSpeed; +} + +void Pinetime::Controllers::MusicService::event(char event) { + auto *om = ble_hs_mbuf_from_flat(&event, 1); + + uint16_t connectionHandle = m_system.nimble().connHandle(); + + if (connectionHandle == 0 || connectionHandle == BLE_HS_CONN_HANDLE_NONE) { + return; + } + + ble_gattc_notify_custom(connectionHandle, eventHandle, om); +} + +int Pinetime::Controllers::MusicService::getProgress() { + return trackProgress; +} + +int Pinetime::Controllers::MusicService::getTrackLength() { + return trackLength; } diff --git a/src/components/ble/MusicService.h b/src/components/ble/MusicService.h index ab6db572..b365909b 100644 --- a/src/components/ble/MusicService.h +++ b/src/components/ble/MusicService.h @@ -1,3 +1,20 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ #pragma once #include @@ -14,78 +31,135 @@ namespace Pinetime { class SystemTask; } namespace Controllers { - + class MusicService { - public: - MusicService(Pinetime::System::SystemTask &system); - void Init(); - int OnCommand(uint16_t conn_handle, uint16_t attr_handle, - struct ble_gatt_access_ctxt *ctxt); - - std::string artist(); - std::string track(); - std::string album(); - unsigned char status(); - - void event(char event); - - static const char EVENT_MUSIC_OPEN = 0xe0; - static const char EVENT_MUSIC_PLAY = 0x00; - static const char EVENT_MUSIC_PAUSE = 0x01; - static const char EVENT_MUSIC_NEXT = 0x03; - static const char EVENT_MUSIC_PREV = 0x04; - static const char EVENT_MUSIC_VOLUP = 0x05; - static const char EVENT_MUSIC_VOLDOWN = 0x06; - static const char STATUS_MUSIC_PAUSED = 0x00; - static const char STATUS_MUSIC_PLAYING = 0x01; - - private: - static constexpr uint8_t msId[2] = {0x00, 0x01}; - static constexpr uint8_t msEventCharId[2] = {0x00, 0x02}; - static constexpr uint8_t msStatusCharId[2] = {0x00, 0x03}; - static constexpr uint8_t msArtistCharId[2] = {0x00, 0x04}; - static constexpr uint8_t msTrackCharId[2] = {0x00, 0x05}; - static constexpr uint8_t msAlbumCharId[2] = {0x00, 0x06}; - - ble_uuid128_t msUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - - ble_uuid128_t msEventCharUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - ble_uuid128_t msStatusCharUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - ble_uuid128_t msArtistCharUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - ble_uuid128_t msTrackCharUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - ble_uuid128_t msAlbumCharUuid { - .u = { .type = BLE_UUID_TYPE_128 }, - .value = MUSIC_SERVICE_UUID_BASE - }; - - struct ble_gatt_chr_def characteristicDefinition[6]; - struct ble_gatt_svc_def serviceDefinition[2]; - - uint16_t m_eventHandle; - - std::string m_artist; - std::string m_album; - std::string m_track; - - unsigned char m_status; - - Pinetime::System::SystemTask& m_system; - + public: + explicit MusicService(Pinetime::System::SystemTask &system); + + void Init(); + + int OnCommand(uint16_t conn_handle, uint16_t attr_handle, + struct ble_gatt_access_ctxt *ctxt); + + void event(char event); + + std::string getArtist(); + + std::string getTrack(); + + std::string getAlbum(); + + int getProgress(); + + int getTrackLength(); + + float getPlaybackSpeed(); + + bool isPlaying(); + + static const char EVENT_MUSIC_OPEN = 0xe0; + static const char EVENT_MUSIC_PLAY = 0x00; + static const char EVENT_MUSIC_PAUSE = 0x01; + static const char EVENT_MUSIC_NEXT = 0x03; + static const char EVENT_MUSIC_PREV = 0x04; + static const char EVENT_MUSIC_VOLUP = 0x05; + static const char EVENT_MUSIC_VOLDOWN = 0x06; + + enum MusicStatus { + NotPlaying = 0x00, + Playing = 0x01 + }; + private: + static constexpr uint8_t msId[2] = {0x00, 0x01}; + static constexpr uint8_t msEventCharId[2] = {0x00, 0x02}; + static constexpr uint8_t msStatusCharId[2] = {0x00, 0x03}; + static constexpr uint8_t msArtistCharId[2] = {0x00, 0x04}; + static constexpr uint8_t msTrackCharId[2] = {0x00, 0x05}; + static constexpr uint8_t msAlbumCharId[2] = {0x00, 0x06}; + static constexpr uint8_t msPositionCharId[2] = {0x00, 0x07}; + static constexpr uint8_t msTotalLengthCharId[2] = {0x00, 0x08}; + static constexpr uint8_t msTrackNumberCharId[2] = {0x00, 0x09}; + static constexpr uint8_t msTrackTotalCharId[2] = {0x00, 0x0a}; + static constexpr uint8_t msPlaybackSpeedCharId[2] = {0x00, 0x0b}; + static constexpr uint8_t msRepeatCharId[2] = {0x00, 0x0c}; + static constexpr uint8_t msShuffleCharId[2] = {0x00, 0x0d}; + + ble_uuid128_t msUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + + ble_uuid128_t msEventCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msStatusCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msArtistCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msTrackCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msAlbumCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msPositionCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msTotalLengthCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msTrackNumberCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msTrackTotalCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msPlaybackSpeedCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msRepeatCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + ble_uuid128_t msShuffleCharUuid{ + .u = {.type = BLE_UUID_TYPE_128}, + .value = MUSIC_SERVICE_UUID_BASE + }; + + struct ble_gatt_chr_def characteristicDefinition[14]; + struct ble_gatt_svc_def serviceDefinition[2]; + + uint16_t eventHandle; + + std::string artistName; + std::string albumName; + std::string trackName; + + bool playing; + + int trackProgress; + int trackLength; + int trackNumber; + int tracksTotal; + + float playbackSpeed; + + bool repeat; + bool shuffle; + + Pinetime::System::SystemTask &m_system; }; } } diff --git a/src/displayapp/icons/music/disc.cpp b/src/displayapp/icons/music/disc.cpp new file mode 100644 index 00000000..0957873f --- /dev/null +++ b/src/displayapp/icons/music/disc.cpp @@ -0,0 +1,110 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC +#define LV_ATTRIBUTE_IMG_DISC +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC uint8_t disc_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x00, 0x00, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0f, 0xf8, 0x07, 0xff, 0xff, + 0xff, 0xff, 0xc0, 0xff, 0xff, 0x81, 0xff, 0xff, + 0xff, 0xff, 0x07, 0xff, 0xff, 0xf0, 0x7f, 0xff, + 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, 0x0f, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xff, + 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, + 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, + 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe3, 0xe3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe7, 0xf3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xe3, 0xe3, 0xff, 0xff, 0xfc, + 0x9f, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xfc, + 0x8f, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, 0xf8, + 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, + 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, + 0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, + 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, + 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, + 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, + 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, + 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, + 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, + 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, + 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xff, + 0xff, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xff, + 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, + 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, 0x0f, 0xff, + 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xff, 0x07, 0xff, 0xff, 0xf0, 0x7f, 0xff, + 0xff, 0xff, 0xc0, 0xff, 0xff, 0x81, 0xff, 0xff, + 0xff, 0xff, 0xf0, 0x0f, 0xf8, 0x07, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x00, 0x00, 0x1f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, +}; + +const lv_img_dsc_t disc = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 64, + 64 + }, + 520, + disc_map +}; \ No newline at end of file diff --git a/src/displayapp/icons/music/disc.png b/src/displayapp/icons/music/disc.png new file mode 100644 index 00000000..699734fb Binary files /dev/null and b/src/displayapp/icons/music/disc.png differ diff --git a/src/displayapp/icons/music/disc_f_1.cpp b/src/displayapp/icons/music/disc_f_1.cpp new file mode 100644 index 00000000..9b6b7417 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_1.cpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC_F_1 +#define LV_ATTRIBUTE_IMG_DISC_F_1 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC_F_1 uint8_t disc_f_1_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, + 0xff, 0xff, 0xfc, 0x00, + 0xff, 0xff, 0xf0, 0x0f, + 0xff, 0xff, 0xc0, 0xff, + 0xff, 0xff, 0x07, 0xff, + 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xff, + 0xff, 0xf0, 0xff, 0xff, + 0xff, 0xe3, 0xff, 0xff, + 0xff, 0xc7, 0xf3, 0xff, + 0xff, 0x8f, 0xc3, 0xff, + 0xff, 0x1f, 0x87, 0xff, + 0xfe, 0x3f, 0x0f, 0xff, + 0xfc, 0x7e, 0x1f, 0xff, + 0xfc, 0x7c, 0x3f, 0xff, + 0xf8, 0xfc, 0x7f, 0xff, + 0xf9, 0xfc, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, + 0xf3, 0xff, 0xff, 0xff, + 0xe3, 0xff, 0xff, 0xff, + 0xe7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, + 0x9f, 0xff, 0xff, 0xe3, + 0x9f, 0xff, 0xff, 0xe7, + 0x9f, 0xff, 0xff, 0xe7, +}; + +const lv_img_dsc_t disc_f_1 = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 32, + 32 + }, + 136, + disc_f_1_map +}; + diff --git a/src/displayapp/icons/music/disc_f_1.png b/src/displayapp/icons/music/disc_f_1.png new file mode 100644 index 00000000..94657734 Binary files /dev/null and b/src/displayapp/icons/music/disc_f_1.png differ diff --git a/src/displayapp/icons/music/disc_f_2.cpp b/src/displayapp/icons/music/disc_f_2.cpp new file mode 100644 index 00000000..3d2331d1 --- /dev/null +++ b/src/displayapp/icons/music/disc_f_2.cpp @@ -0,0 +1,79 @@ +/* Copyright (C) 2020 Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#pragma once + +#include "lvgl/lvgl.h" + +#ifndef LV_ATTRIBUTE_MEM_ALIGN +#define LV_ATTRIBUTE_MEM_ALIGN +#endif + +#ifndef LV_ATTRIBUTE_IMG_DISC_F_2 +#define LV_ATTRIBUTE_IMG_DISC_F_2 +#endif + +const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_IMG_DISC_F_2 uint8_t disc_f_2_map[] = { + 0xbd, 0xc1, 0xbe, 0xff, /* Color of index 0: foreground */ + 0x00, 0x00, 0x00, 0x00, /* Color of index 1: background */ + + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc0, + 0xff, 0xff, 0xfc, 0x00, + 0xff, 0xff, 0xf0, 0x0f, + 0xff, 0xff, 0xc0, 0xff, + 0xff, 0xff, 0x07, 0xff, + 0xff, 0xfc, 0x1f, 0xff, + 0xff, 0xf8, 0x7f, 0xf1, + 0xff, 0xf0, 0xff, 0x00, + 0xff, 0xe3, 0xfc, 0x03, + 0xff, 0xc7, 0xf0, 0x3f, + 0xff, 0x8f, 0xf0, 0xff, + 0xff, 0x1f, 0xf3, 0xff, + 0xfe, 0x3f, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, + 0xfc, 0x7f, 0xff, 0xff, + 0xf8, 0xff, 0xff, 0xff, + 0xf9, 0xff, 0xff, 0xff, + 0xf1, 0xff, 0xff, 0xff, + 0xf3, 0xff, 0xff, 0xff, + 0xe3, 0xff, 0xff, 0xff, + 0xe7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xc7, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0xcf, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xff, + 0x8f, 0xff, 0xff, 0xf8, + 0x9f, 0xff, 0xff, 0xf0, + 0x9f, 0xff, 0xff, 0xe3, + 0x9f, 0xff, 0xff, 0xe7, + 0x9f, 0xff, 0xff, 0xe7, +}; + +const lv_img_dsc_t disc_f_2 = { + { + LV_IMG_CF_INDEXED_1BIT, + 0, + 0, + 32, + 32 + }, + 136, + disc_f_2_map +}; + diff --git a/src/displayapp/icons/music/disc_f_2.png b/src/displayapp/icons/music/disc_f_2.png new file mode 100644 index 00000000..4d9a4a38 Binary files /dev/null and b/src/displayapp/icons/music/disc_f_2.png differ diff --git a/src/displayapp/screens/Music.cpp b/src/displayapp/screens/Music.cpp index 9b7d198b..225a15a4 100644 --- a/src/displayapp/screens/Music.cpp +++ b/src/displayapp/screens/Music.cpp @@ -1,72 +1,131 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ #include + #include "Music.h" using namespace Pinetime::Applications::Screens; + extern lv_font_t jetbrains_mono_extrabold_compressed; extern lv_font_t jetbrains_mono_bold_20; -static void event_handler(lv_obj_t * obj, lv_event_t event) -{ - Music* screen = static_cast(obj->user_data); +static void event_handler(lv_obj_t *obj, lv_event_t event) { + Music *screen = static_cast(obj->user_data); screen->OnObjectEvent(obj, event); } +/** + * Set the pixel array to display by the image + * This just calls lv_img_set_src but adds type safety + * + * @param img pointer to an image object + * @param data the image array + */ +inline void lv_img_set_src_arr(lv_obj_t *img, const lv_img_dsc_t *src_img) { + lv_img_set_src(img, src_img); +} + +/** + * Music control watchapp + * + * TODO: Investigate Apple Media Service and AVRCPv1.6 support for seamless integration + */ Music::Music(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::MusicService &music) : Screen(app), musicService(music) { - lv_obj_t * label; - - btnVolDown = lv_btn_create(lv_scr_act(), NULL); - btnVolDown->user_data = this; - lv_obj_set_event_cb(btnVolDown, event_handler); - lv_obj_align(btnVolDown, NULL, LV_ALIGN_IN_TOP_LEFT, 10, 10); - label = lv_label_create(btnVolDown, NULL); - lv_label_set_text(label, "v-"); - - btnVolUp = lv_btn_create(lv_scr_act(), NULL); - btnVolUp->user_data = this; - lv_obj_set_event_cb(btnVolUp, event_handler); - lv_obj_align(btnVolUp, NULL, LV_ALIGN_IN_TOP_RIGHT, -10, 10); - label = lv_label_create(btnVolUp, NULL); - lv_label_set_text(label, "v+"); - - btnPrev = lv_btn_create(lv_scr_act(), NULL); - btnPrev->user_data = this; - lv_obj_set_event_cb(btnPrev, event_handler); - lv_obj_set_size(btnPrev, LV_HOR_RES / 4, LV_VER_RES / 4); - lv_obj_align(btnPrev, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 10,-10); - label = lv_label_create(btnPrev, NULL); - lv_label_set_text(label, "<<"); - - btnPlayPause = lv_btn_create(lv_scr_act(), NULL); - btnPlayPause->user_data = this; - lv_obj_set_event_cb(btnPlayPause, event_handler); - lv_obj_set_size(btnPlayPause, LV_HOR_RES / 4, LV_VER_RES / 4); - lv_obj_align(btnPlayPause, NULL, LV_ALIGN_IN_BOTTOM_MID, 0,-10); - txtPlayPause = lv_label_create(btnPlayPause, NULL); - lv_label_set_text(txtPlayPause, ">"); - - btnNext = lv_btn_create(lv_scr_act(), NULL); - btnNext->user_data = this; - lv_obj_set_event_cb(btnNext, event_handler); - lv_obj_set_size(btnNext, LV_HOR_RES / 4, LV_VER_RES / 4); - lv_obj_align(btnNext, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, -10,-10); - label = lv_label_create(btnNext, NULL); - lv_label_set_text(label, ">>"); - - txtArtist = lv_label_create(lv_scr_act(), NULL); - lv_label_set_long_mode(txtArtist, LV_LABEL_LONG_SROLL); - lv_obj_align(txtArtist, NULL, LV_ALIGN_IN_LEFT_MID, 0,-20); - lv_label_set_text(txtArtist, "Artist Name"); - lv_label_set_align(txtArtist, LV_LABEL_ALIGN_CENTER); - lv_obj_set_width(txtArtist, LV_HOR_RES); - - txtTrack = lv_label_create(lv_scr_act(), NULL); - lv_label_set_long_mode(txtTrack, LV_LABEL_LONG_DOT); - lv_obj_align(txtTrack, NULL, LV_ALIGN_IN_LEFT_MID, 0,20); - lv_label_set_text(txtTrack, "This is a very long track name"); - lv_label_set_align(txtTrack, LV_LABEL_ALIGN_CENTER); - lv_obj_set_width(txtTrack, LV_HOR_RES); - - musicService.event(Controllers::MusicService::EVENT_MUSIC_OPEN); + lv_obj_t *label; + + btnVolDown = lv_btn_create(lv_scr_act(), nullptr); + btnVolDown->user_data = this; + lv_obj_set_event_cb(btnVolDown, event_handler); + lv_obj_set_size(btnVolDown, LV_HOR_RES / 3, 80); + lv_obj_align(btnVolDown, nullptr, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); + label = lv_label_create(btnVolDown, nullptr); + lv_label_set_text(label, "V-"); + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + + btnVolUp = lv_btn_create(lv_scr_act(), nullptr); + btnVolUp->user_data = this; + lv_obj_set_event_cb(btnVolUp, event_handler); + lv_obj_set_size(btnVolUp, LV_HOR_RES / 3, 80); + lv_obj_align(btnVolUp, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0); + label = lv_label_create(btnVolUp, nullptr); + lv_label_set_text(label, "V+"); + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + + btnPrev = lv_btn_create(lv_scr_act(), nullptr); + btnPrev->user_data = this; + lv_obj_set_event_cb(btnPrev, event_handler); + lv_obj_set_size(btnPrev, LV_HOR_RES / 3, 80); + lv_obj_align(btnPrev, nullptr, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); + label = lv_label_create(btnPrev, nullptr); + lv_label_set_text(label, "<<"); + + btnNext = lv_btn_create(lv_scr_act(), nullptr); + btnNext->user_data = this; + lv_obj_set_event_cb(btnNext, event_handler); + lv_obj_set_size(btnNext, LV_HOR_RES / 3, 80); + lv_obj_align(btnNext, nullptr, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0); + label = lv_label_create(btnNext, nullptr); + lv_label_set_text(label, ">>"); + + btnPlayPause = lv_btn_create(lv_scr_act(), nullptr); + btnPlayPause->user_data = this; + lv_obj_set_event_cb(btnPlayPause, event_handler); + lv_obj_set_size(btnPlayPause, LV_HOR_RES / 3, 80); + lv_obj_align(btnPlayPause, nullptr, LV_ALIGN_IN_BOTTOM_MID, 0, 0); + txtPlayPause = lv_label_create(btnPlayPause, nullptr); + lv_label_set_text(txtPlayPause, ">"); + + txtTrackDuration = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtTrackDuration, LV_LABEL_LONG_SROLL); + lv_obj_align(txtTrackDuration, nullptr, LV_ALIGN_IN_TOP_LEFT, 12, 20); + lv_label_set_text(txtTrackDuration, "--:--/--:--"); + lv_label_set_align(txtTrackDuration, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtTrackDuration, LV_HOR_RES); + + constexpr uint8_t FONT_HEIGHT = 12; + constexpr uint8_t LINE_PAD = 15; + constexpr int8_t MIDDLE_OFFSET = -25; + txtArtist = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtArtist, LV_LABEL_LONG_SROLL); + lv_obj_align(txtArtist, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 1 * FONT_HEIGHT); + lv_label_set_text(txtArtist, "Artist Name"); + lv_label_set_align(txtArtist, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtArtist, LV_HOR_RES); + + txtTrack = lv_label_create(lv_scr_act(), nullptr); + lv_label_set_long_mode(txtTrack, LV_LABEL_LONG_SROLL); + lv_obj_align(txtTrack, nullptr, LV_ALIGN_IN_LEFT_MID, 12, MIDDLE_OFFSET + 2 * FONT_HEIGHT + LINE_PAD); + lv_label_set_text(txtTrack, "This is a very long getTrack name"); + lv_label_set_align(txtTrack, LV_ALIGN_IN_LEFT_MID); + lv_obj_set_width(txtTrack, LV_HOR_RES); + + /** Init animation */ + imgDisc = lv_img_create(lv_scr_act(), nullptr); + lv_img_set_src_arr(imgDisc, &disc); + lv_obj_align(imgDisc, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15, 15); + + imgDiscAnim = lv_img_create(lv_scr_act(), nullptr); + lv_img_set_src_arr(imgDiscAnim, &disc_f_1); + lv_obj_align(imgDiscAnim, nullptr, LV_ALIGN_IN_TOP_RIGHT, -15 - 32, 15); + + frameB = false; + + musicService.event(Controllers::MusicService::EVENT_MUSIC_OPEN); } Music::~Music() { @@ -79,47 +138,155 @@ bool Music::OnButtonPushed() { } bool Music::Refresh() { - - if (m_artist != musicService.artist()) { - m_artist = musicService.artist(); - lv_label_set_text(txtArtist, m_artist.data()); + if (artist != musicService.getArtist()) { + artist = musicService.getArtist(); + currentLength = 0; + lv_label_set_text(txtArtist, artist.data()); + } + + if (track != musicService.getTrack()) { + track = musicService.getTrack(); + currentLength = 0; + lv_label_set_text(txtTrack, track.data()); + } + + if (album != musicService.getAlbum()) { + album = musicService.getAlbum(); + currentLength = 0; + } + + if (playing != musicService.isPlaying()) { + playing = musicService.isPlaying(); + } + + // Because we increment this ourselves, + // we can't compare with the old data directly + // have to update it when there's actually new data + // just to avoid unnecessary draws that make UI choppy + if (lastLength != musicService.getProgress()) { + currentLength = musicService.getProgress(); + lastLength = currentLength; + UpdateLength(); + } + + if (totalLength != musicService.getTrackLength()) { + totalLength = musicService.getTrackLength(); + UpdateLength(); + } + + if (playing == Pinetime::Controllers::MusicService::MusicStatus::Playing) { + lv_label_set_text(txtPlayPause, "||"); + if (xTaskGetTickCount() - 1024 >= lastIncrement) { + + if (frameB) { + lv_img_set_src(imgDiscAnim, &disc_f_1); + } else { + lv_img_set_src(imgDiscAnim, &disc_f_2); + } + frameB = !frameB; + + if (currentLength < totalLength) { + currentLength += static_cast((static_cast(xTaskGetTickCount() - lastIncrement) / 1024.0f) * + musicService.getPlaybackSpeed()); + } else { + // Let's assume the getTrack finished, paused when the timer ends + // and there's no new getTrack being sent to us + // TODO: ideally this would be configurable + playing = false; + } + lastIncrement = xTaskGetTickCount(); + + UpdateLength(); } - if (m_track != musicService.track()) { - m_track = musicService.track(); - lv_label_set_text(txtTrack, m_track.data()); - } - if (m_album != musicService.album()) { - m_album = musicService.album(); - } - if (m_status != musicService.status()) { - m_status = musicService.status(); - } - if (m_status == Pinetime::Controllers::MusicService::STATUS_MUSIC_PLAYING) { - lv_label_set_text(txtPlayPause, "||"); - } else { - lv_label_set_text(txtPlayPause, ">"); - } - + } else { + lv_label_set_text(txtPlayPause, ">"); + } + return running; } -void Music::OnObjectEvent(lv_obj_t* obj, lv_event_t event) -{ - if (event == LV_EVENT_CLICKED) { - if (obj == btnVolDown) { - musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLDOWN); - } else if (obj == btnVolUp) { - musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLUP); - } else if (obj == btnPrev) { - musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV); - } else if (obj == btnPlayPause) { - if (m_status == Pinetime::Controllers::MusicService::STATUS_MUSIC_PLAYING) { - musicService.event(Controllers::MusicService::EVENT_MUSIC_PAUSE); - } else { - musicService.event(Controllers::MusicService::EVENT_MUSIC_PLAY); - } - } else if (obj == btnNext) { - musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT); - } - } +void Music::UpdateLength() { + if (totalLength > (99 * 60 * 60)) { + lv_label_set_text(txtTrackDuration, "Inf/Inf"); + } else if (totalLength > (99 * 60)) { + char timer[12]; + sprintf(timer, "%02d:%02d/%02d:%02d", + (currentLength / (60 * 60)) % 100, + ((currentLength % (60 * 60)) / 60) % 100, + (totalLength / (60 * 60)) % 100, + ((totalLength % (60 * 60)) / 60) % 100 + ); + lv_label_set_text(txtTrackDuration, timer); + } else { + char timer[12]; + sprintf(timer, "%02d:%02d/%02d:%02d", + (currentLength / 60) % 100, + (currentLength % 60) % 100, + (totalLength / 60) % 100, + (totalLength % 60) % 100 + ); + lv_label_set_text(txtTrackDuration, timer); + } } + +void Music::OnObjectEvent(lv_obj_t *obj, lv_event_t event) { + if (event == LV_EVENT_CLICKED) { + if (obj == btnVolDown) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLDOWN); + } else if (obj == btnVolUp) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLUP); + } else if (obj == btnPrev) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV); + } else if (obj == btnPlayPause) { + if (playing == Pinetime::Controllers::MusicService::MusicStatus::Playing) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PAUSE); + + // Let's assume it stops playing instantly + playing = Controllers::MusicService::NotPlaying; + } else { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PLAY); + + // Let's assume it starts playing instantly + // TODO: In the future should check for BT connection for better UX + playing = Controllers::MusicService::Playing; + } + } else if (obj == btnNext) { + musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT); + } + } +} + + +bool Music::OnTouchEvent(Pinetime::Applications::TouchEvents event) { + switch (event) { + case TouchEvents::SwipeUp: { + displayVolumeButtons = true; + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + lv_obj_set_hidden(btnVolUp, !displayVolumeButtons); + + lv_obj_set_hidden(btnNext, displayVolumeButtons); + lv_obj_set_hidden(btnPrev, displayVolumeButtons); + return true; + } + case TouchEvents::SwipeDown: { + displayVolumeButtons = false; + lv_obj_set_hidden(btnNext, displayVolumeButtons); + lv_obj_set_hidden(btnPrev, displayVolumeButtons); + + lv_obj_set_hidden(btnVolDown, !displayVolumeButtons); + lv_obj_set_hidden(btnVolUp, !displayVolumeButtons); + return true; + } + case TouchEvents::SwipeLeft: { + musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT); + return true; + } + case TouchEvents::SwipeRight: { + musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV); + return true; + } + default: { + return true; + } + } +} \ No newline at end of file diff --git a/src/displayapp/screens/Music.h b/src/displayapp/screens/Music.h index d43d31cc..81ba7935 100644 --- a/src/displayapp/screens/Music.h +++ b/src/displayapp/screens/Music.h @@ -1,3 +1,20 @@ +/* Copyright (C) 2020 JF, Adam Pigg, Avamander + + This file is part of InfiniTime. + + InfiniTime is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + InfiniTime is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ #pragma once #include @@ -13,37 +30,66 @@ #include #include #include "../../Version.h" +#include "displayapp/icons/music/disc.cpp" +#include "displayapp/icons/music/disc_f_1.cpp" +#include "displayapp/icons/music/disc_f_2.cpp" namespace Pinetime { namespace Applications { namespace Screens { - - class Music : public Screen{ - public: - Music(DisplayApp* app, Pinetime::Controllers::MusicService &music); - ~Music() override; - - bool Refresh() override; - bool OnButtonPushed() override; - - void OnObjectEvent(lv_obj_t* obj, lv_event_t event); - - private: - lv_obj_t * btnPrev; - lv_obj_t * btnPlayPause; - lv_obj_t * btnNext; - lv_obj_t * btnVolDown; - lv_obj_t * btnVolUp; - lv_obj_t * txtArtist; - lv_obj_t * txtTrack; - lv_obj_t * txtPlayPause; - - bool running = true; - Pinetime::Controllers::MusicService &musicService; - std::string m_artist; - std::string m_album; - std::string m_track; - unsigned char m_status; + class Music : public Screen { + public: + Music(DisplayApp *app, Pinetime::Controllers::MusicService &music); + + ~Music() override; + + bool Refresh() override; + + bool OnButtonPushed() override; + + void OnObjectEvent(lv_obj_t *obj, lv_event_t event); + + private: + bool OnTouchEvent(TouchEvents event); + + void UpdateLength(); + + lv_obj_t *btnPrev; + lv_obj_t *btnPlayPause; + lv_obj_t *btnNext; + lv_obj_t *btnVolDown; + lv_obj_t *btnVolUp; + lv_obj_t *txtArtist; + lv_obj_t *txtTrack; + lv_obj_t *txtPlayPause; + + lv_obj_t *imgDisc; + lv_obj_t *imgDiscAnim; + lv_obj_t *txtTrackDuration; + + /** For the spinning disc animation */ + bool frameB; + + bool displayVolumeButtons = false; + Pinetime::Controllers::MusicService &musicService; + + std::string artist; + std::string album; + std::string track; + + /** Total length in seconds */ + int totalLength; + /** Current length in seconds */ + int currentLength; + /** Last length */ + int lastLength; + /** Last time an animation update or timer was incremented */ + TickType_t lastIncrement; + + bool playing; + + /** Watchapp */ + bool running = true; }; } }