Allow customization of charger animation
Allow the charging animation to be customized with a configuration file and custom assets. - Add a parser to parse a custom configuration file. - Add support for showing a clock and the battery percentage. - Expand feature that conditionally shows animation frames using min_level and level_only to min_level and max_level BUG: 29547343 Change-Id: Ia33f4bb37dc7d4c7fa6507a63481e93bf0bf9738
This commit is contained in:
Damien Bargiacchi
parent
fd8dce5777
commit
565ba02b89
7 changed files with 757 additions and 102 deletions
|
|
@ -18,13 +18,40 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
|
|||
LOCAL_STATIC_LIBRARIES := libutils
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
LOCAL_SRC_FILES := \
|
||||
healthd_mode_android.cpp \
|
||||
healthd_mode_charger.cpp \
|
||||
AnimationParser.cpp \
|
||||
BatteryPropertiesRegistrar.cpp \
|
||||
|
||||
LOCAL_MODULE := libhealthd_internal
|
||||
LOCAL_C_INCLUDES := bootable/recovery
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := \
|
||||
$(LOCAL_PATH) \
|
||||
$(LOCAL_PATH)/include \
|
||||
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
libbatterymonitor \
|
||||
libbatteryservice \
|
||||
libbinder \
|
||||
libminui \
|
||||
libpng \
|
||||
libz \
|
||||
libutils \
|
||||
libbase \
|
||||
libcutils \
|
||||
liblog \
|
||||
libm \
|
||||
libc \
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_SRC_FILES := \
|
||||
healthd.cpp \
|
||||
healthd_mode_android.cpp \
|
||||
healthd_mode_charger.cpp \
|
||||
BatteryPropertiesRegistrar.cpp
|
||||
healthd.cpp \
|
||||
|
||||
LOCAL_MODULE := healthd
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
|
|
@ -44,7 +71,20 @@ endif
|
|||
|
||||
LOCAL_C_INCLUDES := bootable/recovery
|
||||
|
||||
LOCAL_STATIC_LIBRARIES := libbatterymonitor libbatteryservice libbinder libminui libpng libz libutils libcutils liblog libm libc
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
libhealthd_internal \
|
||||
libbatterymonitor \
|
||||
libbatteryservice \
|
||||
libbinder \
|
||||
libminui \
|
||||
libpng \
|
||||
libz \
|
||||
libutils \
|
||||
libbase \
|
||||
libcutils \
|
||||
liblog \
|
||||
libm \
|
||||
libc
|
||||
|
||||
ifeq ($(strip $(BOARD_CHARGER_ENABLE_SUSPEND)),true)
|
||||
LOCAL_STATIC_LIBRARIES += libsuspend
|
||||
|
|
@ -61,7 +101,7 @@ include $(BUILD_EXECUTABLE)
|
|||
|
||||
define _add-charger-image
|
||||
include $$(CLEAR_VARS)
|
||||
LOCAL_MODULE := system_core_charger_$(notdir $(1))
|
||||
LOCAL_MODULE := system_core_charger_res_images_$(notdir $(1))
|
||||
LOCAL_MODULE_STEM := $(notdir $(1))
|
||||
_img_modules += $$(LOCAL_MODULE)
|
||||
LOCAL_SRC_FILES := $1
|
||||
|
|
|
|||
141
healthd/AnimationParser.cpp
Normal file
141
healthd/AnimationParser.cpp
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
/*
|
||||
* Copyright (C) 2016 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 "AnimationParser.h"
|
||||
|
||||
#include <android-base/stringprintf.h>
|
||||
#include <android-base/strings.h>
|
||||
|
||||
#include <cutils/klog.h>
|
||||
|
||||
#include "animation.h"
|
||||
|
||||
#define LOGE(x...) do { KLOG_ERROR("charger", x); } while (0)
|
||||
#define LOGW(x...) do { KLOG_WARNING("charger", x); } while (0)
|
||||
#define LOGV(x...) do { KLOG_DEBUG("charger", x); } while (0)
|
||||
|
||||
namespace android {
|
||||
|
||||
// Lines consisting of only whitespace or whitespace followed by '#' can be ignored.
|
||||
bool can_ignore_line(const char* str) {
|
||||
for (int i = 0; str[i] != '\0' && str[i] != '#'; i++) {
|
||||
if (!isspace(str[i])) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool remove_prefix(const std::string& line, const char* prefix, const char** rest) {
|
||||
const char* str = line.c_str();
|
||||
int start;
|
||||
char c;
|
||||
|
||||
std::string format = base::StringPrintf(" %s%%n%%c", prefix);
|
||||
if (sscanf(str, format.c_str(), &start, &c) != 1) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*rest = &str[start];
|
||||
return true;
|
||||
}
|
||||
|
||||
bool parse_text_field(const char* in, animation::text_field* field) {
|
||||
int* x = &field->pos_x;
|
||||
int* y = &field->pos_y;
|
||||
int* r = &field->color_r;
|
||||
int* g = &field->color_g;
|
||||
int* b = &field->color_b;
|
||||
int* a = &field->color_a;
|
||||
|
||||
int start = 0, end = 0;
|
||||
|
||||
if (sscanf(in, "c c %d %d %d %d %n%*s%n", r, g, b, a, &start, &end) == 4) {
|
||||
*x = CENTER_VAL;
|
||||
*y = CENTER_VAL;
|
||||
} else if (sscanf(in, "c %d %d %d %d %d %n%*s%n", y, r, g, b, a, &start, &end) == 5) {
|
||||
*x = CENTER_VAL;
|
||||
} else if (sscanf(in, "%d c %d %d %d %d %n%*s%n", x, r, g, b, a, &start, &end) == 5) {
|
||||
*y = CENTER_VAL;
|
||||
} else if (sscanf(in, "%d %d %d %d %d %d %n%*s%n", x, y, r, g, b, a, &start, &end) != 6) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (end == 0) return false;
|
||||
|
||||
field->font_file.assign(&in[start], end - start);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool parse_animation_desc(const std::string& content, animation* anim) {
|
||||
static constexpr const char* animation_prefix = "animation: ";
|
||||
static constexpr const char* fail_prefix = "fail: ";
|
||||
static constexpr const char* clock_prefix = "clock_display: ";
|
||||
static constexpr const char* percent_prefix = "percent_display: ";
|
||||
static constexpr const char* frame_prefix = "frame: ";
|
||||
|
||||
std::vector<animation::frame> frames;
|
||||
|
||||
for (const auto& line : base::Split(content, "\n")) {
|
||||
animation::frame frame;
|
||||
const char* rest;
|
||||
|
||||
if (can_ignore_line(line.c_str())) {
|
||||
continue;
|
||||
} else if (remove_prefix(line, animation_prefix, &rest)) {
|
||||
int start = 0, end = 0;
|
||||
if (sscanf(rest, "%d %d %n%*s%n", &anim->num_cycles, &anim->first_frame_repeats,
|
||||
&start, &end) != 2 ||
|
||||
end == 0) {
|
||||
LOGE("Bad animation format: %s\n", line.c_str());
|
||||
return false;
|
||||
} else {
|
||||
anim->animation_file.assign(&rest[start], end - start);
|
||||
}
|
||||
} else if (remove_prefix(line, fail_prefix, &rest)) {
|
||||
anim->fail_file.assign(rest);
|
||||
} else if (remove_prefix(line, clock_prefix, &rest)) {
|
||||
if (!parse_text_field(rest, &anim->text_clock)) {
|
||||
LOGE("Bad clock_display format: %s\n", line.c_str());
|
||||
return false;
|
||||
}
|
||||
} else if (remove_prefix(line, percent_prefix, &rest)) {
|
||||
if (!parse_text_field(rest, &anim->text_percent)) {
|
||||
LOGE("Bad percent_display format: %s\n", line.c_str());
|
||||
return false;
|
||||
}
|
||||
} else if (sscanf(line.c_str(), " frame: %d %d %d",
|
||||
&frame.disp_time, &frame.min_level, &frame.max_level) == 3) {
|
||||
frames.push_back(std::move(frame));
|
||||
} else {
|
||||
LOGE("Malformed animation description line: %s\n", line.c_str());
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (anim->animation_file.empty() || frames.empty()) {
|
||||
LOGE("Bad animation description. Provide the 'animation: ' line and at least one 'frame: ' "
|
||||
"line.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
anim->num_frames = frames.size();
|
||||
anim->frames = new animation::frame[frames.size()];
|
||||
std::copy(frames.begin(), frames.end(), anim->frames);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace android
|
||||
31
healthd/AnimationParser.h
Normal file
31
healthd/AnimationParser.h
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/*
|
||||
* Copyright (C) 2016 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.
|
||||
*/
|
||||
|
||||
#ifndef HEALTHD_ANIMATION_PARSER_H
|
||||
#define HEALTHD_ANIMATION_PARSER_H
|
||||
|
||||
#include "animation.h"
|
||||
|
||||
namespace android {
|
||||
|
||||
bool parse_animation_desc(const std::string& content, animation* anim);
|
||||
|
||||
bool can_ignore_line(const char* str);
|
||||
bool remove_prefix(const std::string& str, const char* prefix, const char** rest);
|
||||
bool parse_text_field(const char* in, animation::text_field* field);
|
||||
} // namespace android
|
||||
|
||||
#endif // HEALTHD_ANIMATION_PARSER_H
|
||||
73
healthd/animation.h
Normal file
73
healthd/animation.h
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
/*
|
||||
* Copyright (C) 2016 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.
|
||||
*/
|
||||
|
||||
#ifndef HEALTHD_ANIMATION_H
|
||||
#define HEALTHD_ANIMATION_H
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <string>
|
||||
|
||||
struct GRSurface;
|
||||
struct GRFont;
|
||||
|
||||
namespace android {
|
||||
|
||||
#define CENTER_VAL INT_MAX
|
||||
|
||||
struct animation {
|
||||
struct frame {
|
||||
int disp_time;
|
||||
int min_level;
|
||||
int max_level;
|
||||
|
||||
GRSurface* surface;
|
||||
};
|
||||
|
||||
struct text_field {
|
||||
std::string font_file;
|
||||
int pos_x;
|
||||
int pos_y;
|
||||
int color_r;
|
||||
int color_g;
|
||||
int color_b;
|
||||
int color_a;
|
||||
|
||||
GRFont* font;
|
||||
};
|
||||
|
||||
std::string animation_file;
|
||||
std::string fail_file;
|
||||
|
||||
text_field text_clock;
|
||||
text_field text_percent;
|
||||
|
||||
bool run;
|
||||
|
||||
frame* frames;
|
||||
int cur_frame;
|
||||
int num_frames;
|
||||
int first_frame_repeats; // Number of times to repeat the first frame in the current cycle
|
||||
|
||||
int cur_cycle;
|
||||
int num_cycles; // Number of cycles to complete before blanking the screen
|
||||
|
||||
int cur_level; // current battery level being animated (0-100)
|
||||
int cur_status; // current battery status - see BatteryService.h for BATTERY_STATUS_*
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // HEALTHD_ANIMATION_H
|
||||
|
|
@ -30,6 +30,9 @@
|
|||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <android-base/file.h>
|
||||
#include <android-base/stringprintf.h>
|
||||
|
||||
#include <sys/socket.h>
|
||||
#include <linux/netlink.h>
|
||||
|
||||
|
|
@ -44,10 +47,14 @@
|
|||
#include <suspend/autosuspend.h>
|
||||
#endif
|
||||
|
||||
#include "animation.h"
|
||||
#include "AnimationParser.h"
|
||||
#include "minui/minui.h"
|
||||
|
||||
#include <healthd/healthd.h>
|
||||
|
||||
using namespace android;
|
||||
|
||||
char *locale;
|
||||
|
||||
#ifndef max
|
||||
|
|
@ -67,8 +74,6 @@ char *locale;
|
|||
#define POWER_ON_KEY_TIME (2 * MSEC_PER_SEC)
|
||||
#define UNPLUGGED_SHUTDOWN_TIME (10 * MSEC_PER_SEC)
|
||||
|
||||
#define BATTERY_FULL_THRESH 95
|
||||
|
||||
#define LAST_KMSG_PATH "/proc/last_kmsg"
|
||||
#define LAST_KMSG_PSTORE_PATH "/sys/fs/pstore/console-ramoops"
|
||||
#define LAST_KMSG_MAX_SZ (32 * 1024)
|
||||
|
|
@ -77,34 +82,14 @@ char *locale;
|
|||
#define LOGW(x...) do { KLOG_WARNING("charger", x); } while (0)
|
||||
#define LOGV(x...) do { KLOG_DEBUG("charger", x); } while (0)
|
||||
|
||||
static constexpr const char* animation_desc_path = "/res/values/charger/animation.txt";
|
||||
|
||||
struct key_state {
|
||||
bool pending;
|
||||
bool down;
|
||||
int64_t timestamp;
|
||||
};
|
||||
|
||||
struct frame {
|
||||
int disp_time;
|
||||
int min_capacity;
|
||||
bool level_only;
|
||||
|
||||
GRSurface* surface;
|
||||
};
|
||||
|
||||
struct animation {
|
||||
bool run;
|
||||
|
||||
struct frame *frames;
|
||||
int cur_frame;
|
||||
int num_frames;
|
||||
|
||||
int cur_cycle;
|
||||
int num_cycles;
|
||||
|
||||
/* current capacity being animated */
|
||||
int capacity;
|
||||
};
|
||||
|
||||
struct charger {
|
||||
bool have_battery_state;
|
||||
bool charger_connected;
|
||||
|
|
@ -119,54 +104,83 @@ struct charger {
|
|||
int boot_min_cap;
|
||||
};
|
||||
|
||||
static struct frame batt_anim_frames[] = {
|
||||
static const struct animation BASE_ANIMATION = {
|
||||
.text_clock = {
|
||||
.pos_x = 0,
|
||||
.pos_y = 0,
|
||||
|
||||
.color_r = 255,
|
||||
.color_g = 255,
|
||||
.color_b = 255,
|
||||
.color_a = 255,
|
||||
|
||||
.font = nullptr,
|
||||
},
|
||||
.text_percent = {
|
||||
.pos_x = 0,
|
||||
.pos_y = 0,
|
||||
|
||||
.color_r = 255,
|
||||
.color_g = 255,
|
||||
.color_b = 255,
|
||||
.color_a = 255,
|
||||
},
|
||||
|
||||
.run = false,
|
||||
|
||||
.frames = nullptr,
|
||||
.cur_frame = 0,
|
||||
.num_frames = 0,
|
||||
.first_frame_repeats = 2,
|
||||
|
||||
.cur_cycle = 0,
|
||||
.num_cycles = 3,
|
||||
|
||||
.cur_level = 0,
|
||||
.cur_status = BATTERY_STATUS_UNKNOWN,
|
||||
};
|
||||
|
||||
|
||||
static struct animation::frame default_animation_frames[] = {
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = 0,
|
||||
.level_only = false,
|
||||
.min_level = 0,
|
||||
.max_level = 19,
|
||||
.surface = NULL,
|
||||
},
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = 20,
|
||||
.level_only = false,
|
||||
.min_level = 0,
|
||||
.max_level = 39,
|
||||
.surface = NULL,
|
||||
},
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = 40,
|
||||
.level_only = false,
|
||||
.min_level = 0,
|
||||
.max_level = 59,
|
||||
.surface = NULL,
|
||||
},
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = 60,
|
||||
.level_only = false,
|
||||
.min_level = 0,
|
||||
.max_level = 79,
|
||||
.surface = NULL,
|
||||
},
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = 80,
|
||||
.level_only = true,
|
||||
.min_level = 80,
|
||||
.max_level = 95,
|
||||
.surface = NULL,
|
||||
},
|
||||
{
|
||||
.disp_time = 750,
|
||||
.min_capacity = BATTERY_FULL_THRESH,
|
||||
.level_only = false,
|
||||
.min_level = 0,
|
||||
.max_level = 100,
|
||||
.surface = NULL,
|
||||
},
|
||||
};
|
||||
|
||||
static struct animation battery_animation = {
|
||||
.run = false,
|
||||
.frames = batt_anim_frames,
|
||||
.cur_frame = 0,
|
||||
.num_frames = ARRAY_SIZE(batt_anim_frames),
|
||||
.cur_cycle = 0,
|
||||
.num_cycles = 3,
|
||||
.capacity = 0,
|
||||
};
|
||||
static struct animation battery_animation = BASE_ANIMATION;
|
||||
|
||||
static struct charger charger_state;
|
||||
static struct healthd_config *healthd_config;
|
||||
|
|
@ -273,8 +287,79 @@ static void android_green(void)
|
|||
gr_color(0xa4, 0xc6, 0x39, 255);
|
||||
}
|
||||
|
||||
// Negative x or y coordinates position the text away from the opposite edge that positive ones do.
|
||||
void determine_xy(const animation::text_field& field, const int length, int* x, int* y)
|
||||
{
|
||||
*x = field.pos_x;
|
||||
*y = field.pos_y;
|
||||
|
||||
int str_len_px = length * field.font->char_width;
|
||||
if (field.pos_x == CENTER_VAL) {
|
||||
*x = (gr_fb_width() - str_len_px) / 2;
|
||||
} else if (field.pos_x >= 0) {
|
||||
*x = field.pos_x;
|
||||
} else { // position from max edge
|
||||
*x = gr_fb_width() + field.pos_x - str_len_px;
|
||||
}
|
||||
|
||||
if (field.pos_y == CENTER_VAL) {
|
||||
*y = (gr_fb_height() - field.font->char_height) / 2;
|
||||
} else if (field.pos_y >= 0) {
|
||||
*y = field.pos_y;
|
||||
} else { // position from max edge
|
||||
*y = gr_fb_height() + field.pos_y - field.font->char_height;
|
||||
}
|
||||
}
|
||||
|
||||
static void 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 (field.font == nullptr || field.font->char_width == 0 || field.font->char_height == 0) return;
|
||||
|
||||
time_t rawtime;
|
||||
time(&rawtime);
|
||||
struct 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);
|
||||
gr_text(field.font, x, y, clock_str, false);
|
||||
}
|
||||
|
||||
static void draw_percent(const animation& anim)
|
||||
{
|
||||
if (anim.cur_level <= 0 || anim.cur_status != BATTERY_STATUS_CHARGING) 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%%", anim.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);
|
||||
gr_text(field.font, x, y, str.c_str(), false);
|
||||
}
|
||||
|
||||
/* returns the last y-offset of where the surface ends */
|
||||
static int draw_surface_centered(struct charger* /*charger*/, GRSurface* surface)
|
||||
static int draw_surface_centered(GRSurface* surface)
|
||||
{
|
||||
int w;
|
||||
int h;
|
||||
|
|
@ -295,7 +380,7 @@ static void draw_unknown(struct charger *charger)
|
|||
{
|
||||
int y;
|
||||
if (charger->surf_unknown) {
|
||||
draw_surface_centered(charger, charger->surf_unknown);
|
||||
draw_surface_centered(charger->surf_unknown);
|
||||
} else {
|
||||
android_green();
|
||||
y = draw_text("Charging!", -1, -1);
|
||||
|
|
@ -303,17 +388,19 @@ static void draw_unknown(struct charger *charger)
|
|||
}
|
||||
}
|
||||
|
||||
static void draw_battery(struct charger *charger)
|
||||
static void draw_battery(const struct charger* charger)
|
||||
{
|
||||
struct animation *batt_anim = charger->batt_anim;
|
||||
struct frame *frame = &batt_anim->frames[batt_anim->cur_frame];
|
||||
const struct animation& anim = *charger->batt_anim;
|
||||
const struct animation::frame& frame = anim.frames[anim.cur_frame];
|
||||
|
||||
if (batt_anim->num_frames != 0) {
|
||||
draw_surface_centered(charger, frame->surface);
|
||||
if (anim.num_frames != 0) {
|
||||
draw_surface_centered(frame.surface);
|
||||
LOGV("drawing frame #%d min_cap=%d time=%d\n",
|
||||
batt_anim->cur_frame, frame->min_capacity,
|
||||
frame->disp_time);
|
||||
anim.cur_frame, frame.min_level,
|
||||
frame.disp_time);
|
||||
}
|
||||
draw_clock(anim);
|
||||
draw_percent(anim);
|
||||
}
|
||||
|
||||
static void redraw_screen(struct charger *charger)
|
||||
|
|
@ -323,7 +410,7 @@ static void redraw_screen(struct charger *charger)
|
|||
clear_screen();
|
||||
|
||||
/* try to display *something* */
|
||||
if (batt_anim->capacity < 0 || batt_anim->num_frames == 0)
|
||||
if (batt_anim->cur_level < 0 || batt_anim->num_frames == 0)
|
||||
draw_unknown(charger);
|
||||
else
|
||||
draw_battery(charger);
|
||||
|
|
@ -342,16 +429,33 @@ static void reset_animation(struct animation *anim)
|
|||
anim->run = false;
|
||||
}
|
||||
|
||||
static void init_status_display(struct animation* anim)
|
||||
{
|
||||
int res;
|
||||
|
||||
if (!anim->text_clock.font_file.empty()) {
|
||||
if ((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()) {
|
||||
if ((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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void update_screen_state(struct charger *charger, int64_t now)
|
||||
{
|
||||
struct animation *batt_anim = charger->batt_anim;
|
||||
int disp_time;
|
||||
|
||||
if (!batt_anim->run || now < charger->next_screen_transition)
|
||||
return;
|
||||
if (!batt_anim->run || now < charger->next_screen_transition) return;
|
||||
|
||||
if (!minui_inited) {
|
||||
|
||||
if (healthd_config && healthd_config->screen_on) {
|
||||
if (!healthd_config->screen_on(batt_prop)) {
|
||||
LOGV("[%" PRId64 "] leave screen off\n", now);
|
||||
|
|
@ -365,6 +469,7 @@ static void update_screen_state(struct charger *charger, int64_t now)
|
|||
|
||||
gr_init();
|
||||
gr_font_size(gr_sys_font(), &char_width, &char_height);
|
||||
init_status_display(batt_anim);
|
||||
|
||||
#ifndef CHARGER_DISABLE_INIT_BLANK
|
||||
gr_fb_blank(true);
|
||||
|
|
@ -373,7 +478,7 @@ static void update_screen_state(struct charger *charger, int64_t now)
|
|||
}
|
||||
|
||||
/* animation is over, blank screen and leave */
|
||||
if (batt_anim->cur_cycle == batt_anim->num_cycles) {
|
||||
if (batt_anim->num_cycles > 0 && batt_anim->cur_cycle == batt_anim->num_cycles) {
|
||||
reset_animation(batt_anim);
|
||||
charger->next_screen_transition = -1;
|
||||
gr_fb_blank(true);
|
||||
|
|
@ -389,21 +494,24 @@ static void update_screen_state(struct charger *charger, int64_t now)
|
|||
if (batt_anim->cur_frame == 0) {
|
||||
|
||||
LOGV("[%" PRId64 "] animation starting\n", now);
|
||||
if (batt_prop && batt_prop->batteryLevel >= 0 && batt_anim->num_frames != 0) {
|
||||
int i;
|
||||
if (batt_prop) {
|
||||
batt_anim->cur_level = batt_prop->batteryLevel;
|
||||
batt_anim->cur_status = batt_prop->batteryStatus;
|
||||
if (batt_prop->batteryLevel >= 0 && batt_anim->num_frames != 0) {
|
||||
/* find first frame given current battery level */
|
||||
for (int i = 0; i < batt_anim->num_frames; i++) {
|
||||
if (batt_anim->cur_level >= batt_anim->frames[i].min_level &&
|
||||
batt_anim->cur_level <= batt_anim->frames[i].max_level) {
|
||||
batt_anim->cur_frame = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* find first frame given current capacity */
|
||||
for (i = 1; i < batt_anim->num_frames; i++) {
|
||||
if (batt_prop->batteryLevel < batt_anim->frames[i].min_capacity)
|
||||
break;
|
||||
// repeat the first frame first_frame_repeats times
|
||||
disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time *
|
||||
batt_anim->first_frame_repeats;
|
||||
}
|
||||
batt_anim->cur_frame = i - 1;
|
||||
|
||||
/* show the first frame for twice as long */
|
||||
disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time * 2;
|
||||
}
|
||||
if (batt_prop)
|
||||
batt_anim->capacity = batt_prop->batteryLevel;
|
||||
}
|
||||
|
||||
/* unblank the screen on first cycle */
|
||||
|
|
@ -416,8 +524,8 @@ static void update_screen_state(struct charger *charger, int64_t now)
|
|||
/* if we don't have anim frames, we only have one image, so just bump
|
||||
* the cycle counter and exit
|
||||
*/
|
||||
if (batt_anim->num_frames == 0 || batt_anim->capacity < 0) {
|
||||
LOGV("[%" PRId64 "] animation missing or unknown battery status\n", now);
|
||||
if (batt_anim->num_frames == 0 || batt_anim->cur_level < 0) {
|
||||
LOGW("[%" PRId64 "] animation missing or unknown battery status\n", now);
|
||||
charger->next_screen_transition = now + BATTERY_UNKNOWN_TIME;
|
||||
batt_anim->cur_cycle++;
|
||||
return;
|
||||
|
|
@ -432,12 +540,11 @@ static void update_screen_state(struct charger *charger, int64_t now)
|
|||
if (charger->charger_connected) {
|
||||
batt_anim->cur_frame++;
|
||||
|
||||
/* if the frame is used for level-only, that is only show it when it's
|
||||
* the current level, skip it during the animation.
|
||||
*/
|
||||
while (batt_anim->cur_frame < batt_anim->num_frames &&
|
||||
batt_anim->frames[batt_anim->cur_frame].level_only)
|
||||
(batt_anim->cur_level < batt_anim->frames[batt_anim->cur_frame].min_level ||
|
||||
batt_anim->cur_level > batt_anim->frames[batt_anim->cur_frame].max_level)) {
|
||||
batt_anim->cur_frame++;
|
||||
}
|
||||
if (batt_anim->cur_frame >= batt_anim->num_frames) {
|
||||
batt_anim->cur_cycle++;
|
||||
batt_anim->cur_frame = 0;
|
||||
|
|
@ -521,7 +628,7 @@ static void process_key(struct charger *charger, int code, int64_t now)
|
|||
LOGW("[%" PRId64 "] booting from charger mode\n", now);
|
||||
property_set("sys.boot_from_charger_mode", "1");
|
||||
} else {
|
||||
if (charger->batt_anim->capacity >= charger->boot_min_cap) {
|
||||
if (charger->batt_anim->cur_level >= charger->boot_min_cap) {
|
||||
LOGW("[%" PRId64 "] rebooting\n", now);
|
||||
android_reboot(ANDROID_RB_RESTART, 0, 0);
|
||||
} else {
|
||||
|
|
@ -672,6 +779,52 @@ static void charger_event_handler(uint32_t /*epevents*/)
|
|||
ev_dispatch();
|
||||
}
|
||||
|
||||
animation* init_animation()
|
||||
{
|
||||
bool parse_success;
|
||||
|
||||
std::string content;
|
||||
if (base::ReadFileToString(animation_desc_path, &content)) {
|
||||
parse_success = parse_animation_desc(content, &battery_animation);
|
||||
} else {
|
||||
LOGW("Could not open animation description at %s\n", animation_desc_path);
|
||||
parse_success = false;
|
||||
}
|
||||
|
||||
if (!parse_success) {
|
||||
LOGW("Could not parse animation description. Using default animation.\n");
|
||||
battery_animation = BASE_ANIMATION;
|
||||
battery_animation.animation_file.assign("charger/battery_scale");
|
||||
battery_animation.frames = default_animation_frames;
|
||||
battery_animation.num_frames = ARRAY_SIZE(default_animation_frames);
|
||||
}
|
||||
if (battery_animation.fail_file.empty()) {
|
||||
battery_animation.fail_file.assign("charger/battery_fail");
|
||||
}
|
||||
|
||||
LOGV("Animation Description:\n");
|
||||
LOGV(" animation: %d %d '%s' (%d)\n",
|
||||
battery_animation.num_cycles, battery_animation.first_frame_repeats,
|
||||
battery_animation.animation_file.c_str(), battery_animation.num_frames);
|
||||
LOGV(" fail_file: '%s'\n", battery_animation.fail_file.c_str());
|
||||
LOGV(" clock: %d %d %d %d %d %d '%s'\n",
|
||||
battery_animation.text_clock.pos_x, battery_animation.text_clock.pos_y,
|
||||
battery_animation.text_clock.color_r, battery_animation.text_clock.color_g,
|
||||
battery_animation.text_clock.color_b, battery_animation.text_clock.color_a,
|
||||
battery_animation.text_clock.font_file.c_str());
|
||||
LOGV(" percent: %d %d %d %d %d %d '%s'\n",
|
||||
battery_animation.text_percent.pos_x, battery_animation.text_percent.pos_y,
|
||||
battery_animation.text_percent.color_r, battery_animation.text_percent.color_g,
|
||||
battery_animation.text_percent.color_b, battery_animation.text_percent.color_a,
|
||||
battery_animation.text_percent.font_file.c_str());
|
||||
for (int i = 0; i < battery_animation.num_frames; i++) {
|
||||
LOGV(" frame %.2d: %d %d %d\n", i, battery_animation.frames[i].disp_time,
|
||||
battery_animation.frames[i].min_level, battery_animation.frames[i].max_level);
|
||||
}
|
||||
|
||||
return &battery_animation;
|
||||
}
|
||||
|
||||
void healthd_mode_charger_init(struct healthd_config* config)
|
||||
{
|
||||
int ret;
|
||||
|
|
@ -689,35 +842,39 @@ void healthd_mode_charger_init(struct healthd_config* config)
|
|||
healthd_register_event(epollfd, charger_event_handler);
|
||||
}
|
||||
|
||||
ret = res_create_display_surface("charger/battery_fail", &charger->surf_unknown);
|
||||
if (ret < 0) {
|
||||
LOGE("Cannot load battery_fail image\n");
|
||||
charger->surf_unknown = NULL;
|
||||
}
|
||||
struct animation* anim = init_animation();
|
||||
charger->batt_anim = anim;
|
||||
|
||||
charger->batt_anim = &battery_animation;
|
||||
ret = res_create_display_surface(anim->fail_file.c_str(), &charger->surf_unknown);
|
||||
if (ret < 0) {
|
||||
LOGE("Cannot load custom battery_fail image. Reverting to built in.\n");
|
||||
ret = res_create_display_surface("charger/battery_fail", &charger->surf_unknown);
|
||||
if (ret < 0) {
|
||||
LOGE("Cannot load built in battery_fail image\n");
|
||||
charger->surf_unknown = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
GRSurface** scale_frames;
|
||||
int scale_count;
|
||||
int scale_fps; // Not in use (charger/battery_scale doesn't have FPS text
|
||||
// chunk). We are using hard-coded frame.disp_time instead.
|
||||
ret = res_create_multi_display_surface("charger/battery_scale", &scale_count, &scale_fps,
|
||||
&scale_frames);
|
||||
ret = res_create_multi_display_surface(anim->animation_file.c_str(),
|
||||
&scale_count, &scale_fps, &scale_frames);
|
||||
if (ret < 0) {
|
||||
LOGE("Cannot load battery_scale image\n");
|
||||
charger->batt_anim->num_frames = 0;
|
||||
charger->batt_anim->num_cycles = 1;
|
||||
} else if (scale_count != charger->batt_anim->num_frames) {
|
||||
anim->num_frames = 0;
|
||||
anim->num_cycles = 1;
|
||||
} else if (scale_count != anim->num_frames) {
|
||||
LOGE("battery_scale image has unexpected frame count (%d, expected %d)\n",
|
||||
scale_count, charger->batt_anim->num_frames);
|
||||
charger->batt_anim->num_frames = 0;
|
||||
charger->batt_anim->num_cycles = 1;
|
||||
scale_count, anim->num_frames);
|
||||
anim->num_frames = 0;
|
||||
anim->num_cycles = 1;
|
||||
} else {
|
||||
for (i = 0; i < charger->batt_anim->num_frames; i++) {
|
||||
charger->batt_anim->frames[i].surface = scale_frames[i];
|
||||
for (i = 0; i < anim->num_frames; i++) {
|
||||
anim->frames[i].surface = scale_frames[i];
|
||||
}
|
||||
}
|
||||
|
||||
ev_sync_key_state(set_key_callback, charger);
|
||||
|
||||
charger->next_screen_transition = -1;
|
||||
|
|
|
|||
21
healthd/tests/Android.mk
Normal file
21
healthd/tests/Android.mk
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
# Copyright 2016 The Android Open Source Project
|
||||
|
||||
LOCAL_PATH:= $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_SRC_FILES := \
|
||||
AnimationParser_test.cpp \
|
||||
|
||||
LOCAL_MODULE := healthd_test
|
||||
LOCAL_MODULE_TAGS := tests
|
||||
|
||||
LOCAL_STATIC_LIBRARIES := \
|
||||
libhealthd_internal \
|
||||
|
||||
LOCAL_SHARED_LIBRARIES := \
|
||||
liblog \
|
||||
libbase \
|
||||
libcutils \
|
||||
|
||||
include $(BUILD_NATIVE_TEST)
|
||||
192
healthd/tests/AnimationParser_test.cpp
Normal file
192
healthd/tests/AnimationParser_test.cpp
Normal file
|
|
@ -0,0 +1,192 @@
|
|||
/*
|
||||
* Copyright (C) 2016 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 "AnimationParser.h"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
using namespace android;
|
||||
|
||||
TEST(AnimationParserTest, Test_can_ignore_line) {
|
||||
EXPECT_TRUE(can_ignore_line(""));
|
||||
EXPECT_TRUE(can_ignore_line(" "));
|
||||
EXPECT_TRUE(can_ignore_line("#"));
|
||||
EXPECT_TRUE(can_ignore_line(" # comment"));
|
||||
|
||||
EXPECT_FALSE(can_ignore_line("text"));
|
||||
EXPECT_FALSE(can_ignore_line("text # comment"));
|
||||
EXPECT_FALSE(can_ignore_line(" text"));
|
||||
EXPECT_FALSE(can_ignore_line(" text # comment"));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_remove_prefix) {
|
||||
static const char TEST_STRING[] = "abcdef";
|
||||
const char* rest = nullptr;
|
||||
EXPECT_FALSE(remove_prefix(TEST_STRING, "def", &rest));
|
||||
// Ignore strings that only consist of the prefix
|
||||
EXPECT_FALSE(remove_prefix(TEST_STRING, TEST_STRING, &rest));
|
||||
|
||||
EXPECT_TRUE(remove_prefix(TEST_STRING, "abc", &rest));
|
||||
EXPECT_STREQ("def", rest);
|
||||
|
||||
EXPECT_TRUE(remove_prefix(" abcdef", "abc", &rest));
|
||||
EXPECT_STREQ("def", rest);
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_text_field) {
|
||||
static const char TEST_FILE_NAME[] = "font_file";
|
||||
static const int TEST_X = 3;
|
||||
static const int TEST_Y = 6;
|
||||
static const int TEST_R = 1;
|
||||
static const int TEST_G = 2;
|
||||
static const int TEST_B = 4;
|
||||
static const int TEST_A = 8;
|
||||
|
||||
static const char TEST_XCENT_YCENT[] = "c c 1 2 4 8 font_file ";
|
||||
static const char TEST_XCENT_YVAL[] = "c 6 1 2 4 8 font_file ";
|
||||
static const char TEST_XVAL_YCENT[] = "3 c 1 2 4 8 font_file ";
|
||||
static const char TEST_XVAL_YVAL[] = "3 6 1 2 4 8 font_file ";
|
||||
static const char TEST_BAD_MISSING[] = "c c 1 2 4 font_file";
|
||||
static const char TEST_BAD_NO_FILE[] = "c c 1 2 4 8";
|
||||
|
||||
animation::text_field out;
|
||||
|
||||
EXPECT_TRUE(parse_text_field(TEST_XCENT_YCENT, &out));
|
||||
EXPECT_EQ(CENTER_VAL, out.pos_x);
|
||||
EXPECT_EQ(CENTER_VAL, out.pos_y);
|
||||
EXPECT_EQ(TEST_R, out.color_r);
|
||||
EXPECT_EQ(TEST_G, out.color_g);
|
||||
EXPECT_EQ(TEST_B, out.color_b);
|
||||
EXPECT_EQ(TEST_A, out.color_a);
|
||||
EXPECT_STREQ(TEST_FILE_NAME, out.font_file.c_str());
|
||||
|
||||
EXPECT_TRUE(parse_text_field(TEST_XCENT_YVAL, &out));
|
||||
EXPECT_EQ(CENTER_VAL, out.pos_x);
|
||||
EXPECT_EQ(TEST_Y, out.pos_y);
|
||||
EXPECT_EQ(TEST_R, out.color_r);
|
||||
EXPECT_EQ(TEST_G, out.color_g);
|
||||
EXPECT_EQ(TEST_B, out.color_b);
|
||||
EXPECT_EQ(TEST_A, out.color_a);
|
||||
EXPECT_STREQ(TEST_FILE_NAME, out.font_file.c_str());
|
||||
|
||||
EXPECT_TRUE(parse_text_field(TEST_XVAL_YCENT, &out));
|
||||
EXPECT_EQ(TEST_X, out.pos_x);
|
||||
EXPECT_EQ(CENTER_VAL, out.pos_y);
|
||||
EXPECT_EQ(TEST_R, out.color_r);
|
||||
EXPECT_EQ(TEST_G, out.color_g);
|
||||
EXPECT_EQ(TEST_B, out.color_b);
|
||||
EXPECT_EQ(TEST_A, out.color_a);
|
||||
EXPECT_STREQ(TEST_FILE_NAME, out.font_file.c_str());
|
||||
|
||||
EXPECT_TRUE(parse_text_field(TEST_XVAL_YVAL, &out));
|
||||
EXPECT_EQ(TEST_X, out.pos_x);
|
||||
EXPECT_EQ(TEST_Y, out.pos_y);
|
||||
EXPECT_EQ(TEST_R, out.color_r);
|
||||
EXPECT_EQ(TEST_G, out.color_g);
|
||||
EXPECT_EQ(TEST_B, out.color_b);
|
||||
EXPECT_EQ(TEST_A, out.color_a);
|
||||
EXPECT_STREQ(TEST_FILE_NAME, out.font_file.c_str());
|
||||
|
||||
EXPECT_FALSE(parse_text_field(TEST_BAD_MISSING, &out));
|
||||
EXPECT_FALSE(parse_text_field(TEST_BAD_NO_FILE, &out));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_animation_desc_basic) {
|
||||
static const char TEST_ANIMATION[] = R"desc(
|
||||
# Basic animation
|
||||
animation: 5 1 test/animation_file
|
||||
frame: 1000 0 100
|
||||
)desc";
|
||||
animation anim;
|
||||
|
||||
EXPECT_TRUE(parse_animation_desc(TEST_ANIMATION, &anim));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_animation_desc_bad_no_animation_line) {
|
||||
static const char TEST_ANIMATION[] = R"desc(
|
||||
# Bad animation
|
||||
frame: 1000 90 10
|
||||
)desc";
|
||||
animation anim;
|
||||
|
||||
EXPECT_FALSE(parse_animation_desc(TEST_ANIMATION, &anim));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_animation_desc_bad_no_frame) {
|
||||
static const char TEST_ANIMATION[] = R"desc(
|
||||
# Bad animation
|
||||
animation: 5 1 test/animation_file
|
||||
)desc";
|
||||
animation anim;
|
||||
|
||||
EXPECT_FALSE(parse_animation_desc(TEST_ANIMATION, &anim));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_animation_desc_bad_animation_line_format) {
|
||||
static const char TEST_ANIMATION[] = R"desc(
|
||||
# Bad animation
|
||||
animation: 5 1
|
||||
frame: 1000 90 10
|
||||
)desc";
|
||||
animation anim;
|
||||
|
||||
EXPECT_FALSE(parse_animation_desc(TEST_ANIMATION, &anim));
|
||||
}
|
||||
|
||||
TEST(AnimationParserTest, Test_parse_animation_desc_full) {
|
||||
static const char TEST_ANIMATION[] = R"desc(
|
||||
# Full animation
|
||||
animation: 5 1 test/animation_file
|
||||
clock_display: 11 12 13 14 15 16 test/time_font
|
||||
percent_display: 21 22 23 24 25 26 test/percent_font
|
||||
|
||||
frame: 10 20 30
|
||||
frame: 40 50 60
|
||||
)desc";
|
||||
animation anim;
|
||||
|
||||
EXPECT_TRUE(parse_animation_desc(TEST_ANIMATION, &anim));
|
||||
|
||||
EXPECT_EQ(5, anim.num_cycles);
|
||||
EXPECT_EQ(1, anim.first_frame_repeats);
|
||||
EXPECT_STREQ("test/animation_file", anim.animation_file.c_str());
|
||||
|
||||
EXPECT_EQ(11, anim.text_clock.pos_x);
|
||||
EXPECT_EQ(12, anim.text_clock.pos_y);
|
||||
EXPECT_EQ(13, anim.text_clock.color_r);
|
||||
EXPECT_EQ(14, anim.text_clock.color_g);
|
||||
EXPECT_EQ(15, anim.text_clock.color_b);
|
||||
EXPECT_EQ(16, anim.text_clock.color_a);
|
||||
EXPECT_STREQ("test/time_font", anim.text_clock.font_file.c_str());
|
||||
|
||||
EXPECT_EQ(21, anim.text_percent.pos_x);
|
||||
EXPECT_EQ(22, anim.text_percent.pos_y);
|
||||
EXPECT_EQ(23, anim.text_percent.color_r);
|
||||
EXPECT_EQ(24, anim.text_percent.color_g);
|
||||
EXPECT_EQ(25, anim.text_percent.color_b);
|
||||
EXPECT_EQ(26, anim.text_percent.color_a);
|
||||
EXPECT_STREQ("test/percent_font", anim.text_percent.font_file.c_str());
|
||||
|
||||
EXPECT_EQ(2, anim.num_frames);
|
||||
|
||||
EXPECT_EQ(10, anim.frames[0].disp_time);
|
||||
EXPECT_EQ(20, anim.frames[0].min_level);
|
||||
EXPECT_EQ(30, anim.frames[0].max_level);
|
||||
|
||||
EXPECT_EQ(40, anim.frames[1].disp_time);
|
||||
EXPECT_EQ(50, anim.frames[1].min_level);
|
||||
EXPECT_EQ(60, anim.frames[1].max_level);
|
||||
}
|
||||
Loading…
Reference in a new issue