blob: 3e73fcd0849c6398a34d9b148ab77d0e21e7bc6c [file] [log] [blame]
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <android-base/stringprintf.h>
#include <batteryservice/BatteryService.h>
#include <cutils/klog.h>
#include "healthd_draw.h"
#if !defined(__ANDROID_VNDK__)
#include "charger.sysprop.h"
#endif
#define LOGE(x...) KLOG_ERROR("charger", x);
#define LOGW(x...) KLOG_WARNING("charger", x);
#define LOGV(x...) KLOG_DEBUG("charger", x);
static bool get_split_screen() {
#if !defined(__ANDROID_VNDK__)
return android::sysprop::ChargerProperties::draw_split_screen().value_or(false);
#else
return false;
#endif
}
static int get_split_offset() {
#if !defined(__ANDROID_VNDK__)
int64_t value = android::sysprop::ChargerProperties::draw_split_offset().value_or(0);
#else
int64_t value = 0;
#endif
if (value < static_cast<int64_t>(std::numeric_limits<int>::min())) {
LOGW("draw_split_offset = %" PRId64 " overflow for an int; resetting to %d.\n", value,
std::numeric_limits<int>::min());
value = std::numeric_limits<int>::min();
}
if (value > static_cast<int64_t>(std::numeric_limits<int>::max())) {
LOGW("draw_split_offset = %" PRId64 " overflow for an int; resetting to %d.\n", value,
std::numeric_limits<int>::max());
value = std::numeric_limits<int>::max();
}
return static_cast<int>(value);
}
HealthdDraw::HealthdDraw(animation* anim)
: kSplitScreen(get_split_screen()), kSplitOffset(get_split_offset()) {
graphics_available = true;
sys_font = gr_sys_font();
if (sys_font == nullptr) {
LOGW("No system font, screen fallback text not available\n");
} else {
gr_font_size(sys_font, &char_width_, &char_height_);
}
screen_width_ = gr_fb_width() / (kSplitScreen ? 2 : 1);
screen_height_ = gr_fb_height();
int res;
if (!anim->text_clock.font_file.empty() &&
(res = gr_init_font(anim->text_clock.font_file.c_str(), &anim->text_clock.font)) < 0) {
LOGE("Could not load time font (%d)\n", res);
}
if (!anim->text_percent.font_file.empty() &&
(res = gr_init_font(anim->text_percent.font_file.c_str(), &anim->text_percent.font)) < 0) {
LOGE("Could not load percent font (%d)\n", res);
}
}
HealthdDraw::~HealthdDraw() {}
void HealthdDraw::redraw_screen(const animation* batt_anim, GRSurface* surf_unknown) {
if (!graphics_available) return;
clear_screen();
/* try to display *something* */
if (batt_anim->cur_status == BATTERY_STATUS_UNKNOWN || batt_anim->cur_level < 0 ||
batt_anim->num_frames == 0)
draw_unknown(surf_unknown);
else
draw_battery(batt_anim);
gr_flip();
}
void HealthdDraw::blank_screen(bool blank, int drm) {
if (!graphics_available) return;
gr_fb_blank(blank, drm);
}
/* support screen rotation for foldable phone */
void HealthdDraw::rotate_screen(int drm) {
if (!graphics_available) return;
if (drm == 0)
gr_rotate(GRRotation::RIGHT /* landscape mode */);
else
gr_rotate(GRRotation::NONE /* Portrait mode */);
}
void HealthdDraw::clear_screen(void) {
if (!graphics_available) return;
gr_color(0, 0, 0, 255);
gr_clear();
}
int HealthdDraw::draw_surface_centered(GRSurface* surface) {
if (!graphics_available) return 0;
int w = gr_get_width(surface);
int h = gr_get_height(surface);
int x = (screen_width_ - w) / 2 + kSplitOffset;
int y = (screen_height_ - h) / 2;
LOGV("drawing surface %dx%d+%d+%d\n", w, h, x, y);
gr_blit(surface, 0, 0, w, h, x, y);
if (kSplitScreen) {
x += screen_width_ - 2 * kSplitOffset;
LOGV("drawing surface %dx%d+%d+%d\n", w, h, x, y);
gr_blit(surface, 0, 0, w, h, x, y);
}
return y + h;
}
int HealthdDraw::draw_text(const GRFont* font, int x, int y, const char* str) {
if (!graphics_available) return 0;
int str_len_px = gr_measure(font, str);
if (x < 0) x = (screen_width_ - str_len_px) / 2;
if (y < 0) y = (screen_height_ - char_height_) / 2;
gr_text(font, x + kSplitOffset, y, str, false /* bold */);
if (kSplitScreen) gr_text(font, x - kSplitOffset + screen_width_, y, str, false /* bold */);
return y + char_height_;
}
void HealthdDraw::determine_xy(const animation::text_field& field,
const int length, int* x, int* y) {
*x = field.pos_x;
screen_width_ = gr_fb_width() / (kSplitScreen ? 2 : 1);
screen_height_ = gr_fb_height();
int str_len_px = length * field.font->char_width;
if (field.pos_x == CENTER_VAL) {
*x = (screen_width_ - str_len_px) / 2;
} else if (field.pos_x >= 0) {
*x = field.pos_x;
} else { // position from max edge
*x = screen_width_ + field.pos_x - str_len_px - kSplitOffset;
}
*y = field.pos_y;
if (field.pos_y == CENTER_VAL) {
*y = (screen_height_ - field.font->char_height) / 2;
} else if (field.pos_y >= 0) {
*y = field.pos_y;
} else { // position from max edge
*y = screen_height_ + field.pos_y - field.font->char_height;
}
}
void HealthdDraw::draw_clock(const animation* anim) {
static constexpr char CLOCK_FORMAT[] = "%H:%M";
static constexpr int CLOCK_LENGTH = 6;
const animation::text_field& field = anim->text_clock;
if (!graphics_available || field.font == nullptr || field.font->char_width == 0 ||
field.font->char_height == 0)
return;
time_t rawtime;
time(&rawtime);
tm* time_info = localtime(&rawtime);
char clock_str[CLOCK_LENGTH];
size_t length = strftime(clock_str, CLOCK_LENGTH, CLOCK_FORMAT, time_info);
if (length != CLOCK_LENGTH - 1) {
LOGE("Could not format time\n");
return;
}
int x, y;
determine_xy(field, length, &x, &y);
LOGV("drawing clock %s %d %d\n", clock_str, x, y);
gr_color(field.color_r, field.color_g, field.color_b, field.color_a);
draw_text(field.font, x, y, clock_str);
}
void HealthdDraw::draw_percent(const animation* anim) {
if (!graphics_available) return;
int cur_level = anim->cur_level;
if (anim->cur_status == BATTERY_STATUS_FULL) {
cur_level = 100;
}
if (cur_level < 0) return;
const animation::text_field& field = anim->text_percent;
if (field.font == nullptr || field.font->char_width == 0 || field.font->char_height == 0) {
return;
}
std::string str = base::StringPrintf("%d%%", cur_level);
int x, y;
determine_xy(field, str.size(), &x, &y);
LOGV("drawing percent %s %d %d\n", str.c_str(), x, y);
gr_color(field.color_r, field.color_g, field.color_b, field.color_a);
draw_text(field.font, x, y, str.c_str());
}
void HealthdDraw::draw_battery(const animation* anim) {
if (!graphics_available) return;
const animation::frame& frame = anim->frames[anim->cur_frame];
if (anim->num_frames != 0) {
draw_surface_centered(frame.surface);
LOGV("drawing frame #%d min_cap=%d time=%d\n", anim->cur_frame, frame.min_level,
frame.disp_time);
}
draw_clock(anim);
draw_percent(anim);
}
void HealthdDraw::draw_unknown(GRSurface* surf_unknown) {
int y;
if (surf_unknown) {
draw_surface_centered(surf_unknown);
} else if (sys_font) {
gr_color(0xa4, 0xc6, 0x39, 255);
y = draw_text(sys_font, -1, -1, "Charging!");
draw_text(sys_font, -1, y + 25, "?\?/100");
} else {
LOGW("Charging, level unknown\n");
}
}
std::unique_ptr<HealthdDraw> HealthdDraw::Create(animation *anim) {
if (gr_init() < 0) {
LOGE("gr_init failed\n");
return nullptr;
}
return std::unique_ptr<HealthdDraw>(new HealthdDraw(anim));
}