关机充电图标修改

关机充电图标修改
1. 关机充电main函数
2. 函数set_draw_anim_mode()
3. 函数pthread_mutex_init();
4. 函数bootlogo_init()
5. 函数alarm_control();
6. 函数charging_control();
6.1 draw_thread_routine()
6.2 draw_with_interval()
6.3 bootlogo_show_charging()
6.4 show_battery_capacity()
6.5 fill_animation_battery_by_ver()
6.6 fill_animation_battery_new()与fill_animation_battery_old
7. 函数 key_control(pwrkeys, ARRAY_SIZE(pwrkeys));
8. solution
8.1 图片替换
8.2 修改vendor/mediatek/proprietary/external/charger/bootlogo.cpp文件
8.3 修改vendor/jrdcom/build/common/update_logo.sh文件
8.4 修改vendor/mediatek/proprietary/external/libshowlogo/cust_display.h文件
8.5 修改vendor/mediatek/proprietary/external/libshowlogo/show_animation_common.h文件
8.6 修改vendor/mediatek/proprietary/external/libshowlogo/show_animation_common.c文件
9. 总结

这几天解一个defect，主要需求是修改关机充电的图标，把原来的样式进行修该成如图1所示样子：

图 1
修改后充电各个阶段具体要求如图2所示：

图 2
原本的样式为蓝色电池，充电动画为电量波动状，期望修改后变成5格滚动状。(其实个人感觉还是原本的好看，而新样式设计是一个UE做，反正觉得她这个设计很脑残而且估计是抄袭把别的手机的样式吧，而且这个UE很坑壁，给的图片根本不符合要求，后面还要和她各种斯比各种gloomy).

分析如下：

  • 首先，需要找到原来版本充电图片所在位置，然后用新的图片替换掉原版本的充电图片。
    在原版本中，充电logo图片实际上是由多个位图组合起来的。如图中充电电量95%则是由3张图片组合而成，而蓝色的电池部分是由一个白的电池形状图片和蓝色条状图片组合起来的。修改logo图标即使用大小尺寸一样的图片替换掉原来图片，在替换图片时，最好是按原来图片的方式来命令新的图片名字，这样就可以不用修改具体代码的逻辑了。(后面发现还是要该部分代码)
  • 然后，和原版图标相比新样式的logo图标，各个位图的相对位置有所更改。需要找到控制位图坐标的代码并进行修改调整。
  • 最后，在连接充电器时，首先需要显示连接充电器的logo图片一秒，然后才显示充电电量的logo图标，所以需要在显示充电电量图片前加入显示该图片的逻辑。(其实原本的关机充电中，连接充电器会显示一张logo,应该是改此处)

1. 关机充电main函数

关机充电其实是一个单独的应用，主要是由init进程开启，充电部分相关源码主要在vendor/mediatek/proprietary/external/charger/目录下。应用的入口在文件vendor/mediatek/proprietary/external/charger/main.cpp中，首先看看main函数。

  1. int main(int argc, char *argv[]) 
  2. {
  4.     set_draw_anim_mode(1);
  5.     pthread_mutex_init(&lights_mutex, NULL);
  6.     setpriority(PRIO_PROCESS, 0, -20);
  7.     FILE *oom_adj = fopen("/proc/self/oom_adj", "w");
  8.     if (oom_adj) {
  9.         fputs("-17", oom_adj);
  10.         fclose(oom_adj);
  11.     }
  12.     //stop_backlight();
  13.     KPOC_LOGI("stop_backlight 1\n");
  14.     bootlogo_init();
  15.     alarm_control();
  16.     charging_control();
  17.     int i;
  18.     for (i=0; i< ARRAY_SIZE(pwrkeys); i++)
  19.     KPOC_LOGI("pwrkeys[%d]:%d\n",i,pwrkeys[i]);
  20.     key_control(pwrkeys, ARRAY_SIZE(pwrkeys)); //will loop inside
  21.     return 0;
  22. }

2. 函数set_draw_anim_mode()

为设置充电动画的绘制模式，其中有2个模式：

  • DRAW_ANIM_MODE_SURFACE
  • DRAW_ANIM_MODE_SURFACE

3. 函数pthread_mutex_init();

这个函数作用没看懂，略过。

4. 函数bootlogo_init()

这个函数从名字上就可以看出主要是做一些初始化工作，主要包括充电动画版本(mtk有2个充电动画的版本)、动画绘制方式以及其他参数的初始化，下面看看这个函数的具体实现。

  1. void bootlogo_init()
  2. {
  3.     KPOC_LOGI("[ChargingAnimation: %s %d]\n",__FUNCTION__,__LINE__);
  4.     sync_anim_version();
  5.     anim_init();
  6. }

在bootlogo_init();中有2个函数

  • sync_anim_version();

主要是设定关机充电充电动画的版本，
version 0: show 4 recatangle growing animation without battery number
version 1: show wave animation with battery number
所以在这里控制了到底是用哪种充电动画

  • anim_init();

充电动画logo初始化，应该就是获得充电图片的在文件系统中的位置吧，方便后面调用指定图片。

5. 函数alarm_control();

这个函数作用没看懂，略过。

6. 函数charging_control();

这个函数比较重要，主要控制充电时led灯和动画效果的，具体来看看它的代码实现。

  1. void charging_control()
  2. {
  3.     int ret = 0;
  4.     pthread_attr_t attr, attrd, attrl;
  5.     pthread_t uevent_thread, draw_thread, light_thread;
  7.     //charging led control
  8.     if (!is_charging_source_available()) {
  9.         lights_exit();
  10.     }
  11.     pthread_mutex_init(&mutexlstate, NULL);
  12.     pthread_mutex_init(&mutex, NULL);
  13.     pthread_cond_init(&cond, NULL);
  14.     pthread_attr_init(&attr);
  15.     pthread_attr_init(&attrd);
  16.     pthread_attr_init(&attrl);
  17.     inDraw = 0;
  18.     ret = pthread_create(&uevent_thread, &attr, uevent_thread_routine, NULL);
  19.     if (ret != 0) 
  20.     {
  21.         KPOC_LOGI("create uevt pthread failed.\n");
  22.         exit_charger(EXIT_ERROR_SHUTDOWN);
  23.     }
  24.     firstTime = 1;
  25.     ret = pthread_create(&draw_thread, &attrd, draw_thread_routine, NULL);
  26.     if (ret != 0) 
  27.     {
  28.         KPOC_LOGI("create draw pthread failed.\n");
  29.         exit_charger(EXIT_ERROR_SHUTDOWN);
  30.     }
  31. }

在该函数中，最开始对led进行检测，然后是对线程资源的初始化，后面分别开了2个线程，第一个线程主要是操作led灯的，第二个线程是操作充电动画效果的。

6.1 draw_thread_routine()

接下来看看函数draw_thread_routine()做了些什么。

  • 首先，是一些变量值的初始化，
  • 然后，进入while循环，这个while循环应该至始至终都在运行，先是等了charging_source_waiting_interval_ms长时间，保证charging_source_available准备好（实际上并没有真的等charging_source_waiting_interval_ms长时间，只要usb_online、ac_online、wireless_online、vchr中有一个满足就会跳出等待状态），同时if(firstTime)语句只会跑一次，后面都不会执行了。之后跑充电动画，在动画跑完后执行stop_backlight();看名字该是熄灭背光灯，这时候背光灯熄灭后，还执行了 bootlogo_show_charging(bc, 1);显示图片，因为背光灯熄灭了，这个图片是看不到的。那它这么做事为了干什么呢，可能是为了等下次背光灯亮起来而当前图片还没显示出来的情况下，先用bootlogo_show_charging(bc, 1);显示出图片做个缓冲吧。
  • 最后，应该是通过锁阻塞线程，让这个while循环停止在某个状态，当阻塞条件解除后继续while循环（或者说继续播放充电动画，当然这只是猜测，其实没看懂while循环后面部分那些线程锁的作用）。
  1. static void* draw_thread_routine(void *arg)
  2. {
  3.     int i, bc, bc_offset = 0;
  4.     int fd_fb = -1, err =0;
  5.     char buf[PROPERTY_VALUE_MAX];
  6.     char filename[32] = {0};
  7.     // protect the following critical section for the 1st time
  8.     pthread_mutex_lock(&mutex);
  9.     do {
  10.         KPOC_LOGI("draw thread working...\n");
  11.         // move here to avoid suspend when syncing with surfaceflinger
  12.         if(firstTime){
  13.             // make sure charging source online when in KPOC mode
  14.             // add 2s tolerance
  15.             if(wait_until(is_charging_source_available, 
  16.                         charging_source_waiting_duration_ms,
  17.                         charging_source_waiting_interval_ms))
  18.             {
  19.                 KPOC_LOGI("wait until charging source available\n");
  20.             }else{
  21.                 KPOC_LOGI("charging source not available for %d ms at KPOC starup\n",
  22.                         charging_source_waiting_duration_ms);
  23.             }
  24.             firstTime = 0;
  25.         }
  26.         inDraw = 1;
  27.         // check the bc offest value
  28.         bc = get_capacity();
  29.         //动画播放的函数
  30.         draw_with_interval(bootlogo_show_charging, bc, nChgAnimDuration_msec,    nCbInterval_msec);
  31.         stop_backlight();
  32.         // @@@ draw fb again to refresh ddp
  33.         bootlogo_show_charging(bc, 1);
  34.         /* make fb blank */
  35.         snprintf(filename, sizeof(filename), "/dev/graphics/fb0");
  36.         fd_fb = open(filename, O_RDWR);
  37.         if (fd_fb < 0) {
  38.             KPOC_LOGI("Failed to open fb0 device: %s", strerror(errno));
  39.         }
  40.         err = ioctl(fd_fb, FBIOBLANK, FB_BLANK_POWERDOWN);
  41.         if (err < 0) {
  42.             KPOC_LOGI("Failed to blank fb0 device: %s", strerror(errno));
  43.         }
  44.         if (fd_fb >= 0)
  45.             close(fd_fb);
  46.         request_suspend(true);
  47.         inDraw = 0;
  48.         pthread_mutex_unlock(&mutex);
  49.         KPOC_LOGI("draw thread waiting...\n");
  50.         pthread_mutex_lock(&mutex);
  51.         pthread_cond_wait(&cond, &mutex);
  52.     } while(1);
  53.     pthread_exit(NULL);
  54.     return NULL;
  55. }

6.2 draw_with_interval()

这个函数功能主要是设置播放充电动画时长和动画图片间时间间隔的

  • 参数1：void (*func)(int, int) 这个就是进行图片显示的函数，通过它循环调用它实现动画效果
  • 参数2：int bc 这个参数没搞懂是做什么用的
  • 参数3：int total_time_msec 看名字就知道是播放动画的总时长
  • 参数4：int interval_msec 上一个图片和下一个图片之间的时间间隔
  1. // total_time : ms
  2. // interval : ms
  3. static void draw_with_interval(void (*func)(int, int), int bc, int total_time_msec, int interval_msec)
  4. {
  5.     struct timeval start;
  6.     int resume_started = 0, backlight_started = 0, cnt = 0;
  7.     int fd_fb = -1, err = 0;
  8.     char filename[32] = {0};
  9.     gettimeofday(&start, NULL);
  10.  /*这里的while循环就是动画效果的实现，不断的调用显示不同图片的函数来达到动态效果，当播放时长达到total_time_msec设定值或者有power键按下，跳出while循环停止动画效果*/
  11.     while(!time_exceed(start, total_time_msec) && !key_trigger_suspend)
  12.     {
  13.         // check if need to draw animation before performing drawing
  14.         if (!is_charging_source_available())
  15.             return;
  16.         if (!resume_started) {
  17.             resume_started = 1;
  18.             request_suspend(false);
  19.             /* make fb unblank */
  20.             snprintf(filename, sizeof(filename), "/dev/graphics/fb0");
  21.             fd_fb = open(filename, O_RDWR);
  22.             if (fd_fb < 0) {
  23.                 KPOC_LOGI("Failed to open fb0 device: %s", strerror(errno));
  24.             }
  25.             err = ioctl(fd_fb, FBIOBLANK, FB_BLANK_UNBLANK);
  26.             if (err < 0) {
  27.                 KPOC_LOGI("Failed to unblank fb0 device: %s", strerror(errno));
  28.             }
  29.             if (fd_fb >= 0)
  30.                 close(fd_fb);
  31.         }
  33.         func(bc, ++cnt);
  34.         if (!backlight_started) {
  35.             backlight_started = 1;
  36.             usleep(200*1000);
  37.             start_backlight();
  38.         }
  39.         KPOC_LOGI("draw_with_interval... key_trigger_suspend = %d\n",key_trigger_suspend);
  40.         /*这里就上一个图片和下一个图片之间的时间间隔，通过usleep();实现，它是以微秒为单位的。如果设置的时间长，播放的速度就比较慢，如果设置的时间短，播放的速度就比较快*/
  41.         usleep(interval_msec*1000);
  42.     }
  43. }

6.3 bootlogo_show_charging()

然后是函数bootlogo_show_charging，就是通过它来显示充电动画的图片和显示充电电量的。

  1. /*
  2. * Show charging animation with battery capacity
  3.  *
  4.  */
  5. void bootlogo_show_charging(int capacity, int cnt)
  6. {
  7.    KPOC_LOGI("[ChargingAnimation: %s %d]%d, %d",__FUNCTION__,__LINE__, capacity, cnt);
  9.   if (get_battnotify_status())
  10.    {
  11.        KPOC_LOGI("[ChargingAnimation: %s %d] show_charger_error_logo, get_battnotify_status()= %d \n",__FUNCTION__,__LINE__, get_battnotify_status());
  12.      show_charger_ov_logo();
  13.        return;
  14.    }
  15.    if (showLowBattLogo)
  16.     {
  17.        KPOC_LOGI("[ChargingAnimation: %s %d] show_low_battery , showLowBattLogo = %d \n",__FUNCTION__,__LINE__,showLowBattLogo);
  18.        show_low_battery();
  19.       return;
  20.     }
  21.    show_battery_capacity(capacity);
  22. }

show_charger_ov_logo();和 show_low_battery();分别显示电压过高的图片和低电量图片，如果出现这2个情况中一个，就return;，程序就不在向下走了，否则根据当前的电量来显示不的动画效果。

6.4 show_battery_capacity()

show_battery_capacity同样是在根据不同的动画版本（version 0 or version 1）来决定如何在屏幕上显示动画，

  1. /*
  2.  * Show charging animation with battery capacity
  3.  *
  4.  */
  5. void show_battery_capacity(unsigned int capacity)
  6. {
  7.     if (MTK_LOG_ENABLE == 1) {
  8.         SLOGD("[libshowlogo: %s %d]capacity =%d\n",__FUNCTION__,__LINE__, capacity);
  9.     }
  11.     if (draw_anim_mode == (DRAW_ANIM_MODE_FB)) {
  12.         anim_fb_addr_switch();
  13. #if defined(MTK_PUMP_EXPRESS_SUPPORT) || defined(MTK_PUMP_EXPRESS_PLUS_SUPPORT) || defined(MTK_PUMP_EXPRESS_PLUS_20_SUPPORT)
  14.         if (2 != show_animationm_ver && get_fast_charging_state()) {
  15.             fill_animation_battery_fast_charging(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
  16.         } else {
  17.             fill_animation_battery_by_ver(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
  18.         }
  19. #else
  20.         fill_animation_battery_by_ver(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
  21. #endif
  22.         anim_fb_disp_update();
  23.     } else {
  24.         ARect tmpRect;
  25.         tmpRect.left = 0;
  26.         tmpRect.top = 0;
  27.         tmpRect.right = phical_screen.width;
  28.         tmpRect.bottom = phical_screen.height;
  30.         status_t  lockResult = surface->lock(&outBuffer, &tmpRect);
  31.         if (MTK_LOG_ENABLE == 1) {
  32.             SLOGD("[libshowlogo: %s %d]outBuffer.bits = %d, surface->lock return =  0x%08x,\n",__FUNCTION__,__LINE__, (int)outBuffer.bits,lockResult);
  33.         }
  35.         if (0 == lockResult)
  36.         {
  37. #if defined(MTK_PUMP_EXPRESS_SUPPORT) || defined(MTK_PUMP_EXPRESS_PLUS_SUPPORT) || defined(MTK_PUMP_EXPRESS_PLUS_20_SUPPORT)
  38.             if (2 != show_animationm_ver && get_fast_charging_state()) {
  39.                 fill_animation_battery_fast_charging(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
  40.             } else {
  41.                 fill_animation_battery_by_ver(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
  42.             }
  43. #else
  44.             fill_animation_battery_by_ver(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
  45. #endif
  46.             surface->unlockAndPost();
  47.         }
  48.     }
  49. }

6.5 fill_animation_battery_by_ver()

在vendor/mediatek/proprietary/external/libshowlogo/show_animation_common.c文件中的fill_animation_battery_by_ver方法控制关机充电的样式，根本不同的version值使用不同充电动画，方法具体实现如下。

  1. /*
  2.  * Show charging animation by version
  3.  *
  4.  */
  5. void fill_animation_battery_by_ver(int capacity, void *fill_addr, void * dec_logo_addr, void * logo_addr,
  6.                         LCM_SCREEN_T phical_screen, int version)
  7. {
  8.     if (MTK_LOG_ENABLE == 1) {
  9.         SLOGD("[show_animation_common: %s %d]version : %d\n",__FUNCTION__,__LINE__, version);
  10.     }
  11.     switch (version)
  12.     {
  13.         case VERION_OLD_ANIMATION:
  14.             fill_animation_battery_old(capacity, fill_addr, dec_logo_addr, logo_addr, phical_screen);
  16.             break;
  17.         case VERION_NEW_ANIMATION:
  18.             fill_animation_battery_new(capacity, fill_addr, dec_logo_addr, logo_addr, phical_screen);
  20.             break;
  21.         case VERION_WIRELESS_CHARGING_ANIMATION:
  22.             fill_animation_battery_wireless_charging(capacity, fill_addr, dec_logo_addr, logo_addr, phical_screen);
  24.             break;
  25.         default:
  26.             fill_animation_battery_old(capacity, fill_addr, dec_logo_addr, logo_addr, phical_screen);
  28.             break;
  29.     }
  30. }

然后继续查找show_animationm_ver赋值情况，可以看到文件开始位置有如下赋值语句：

  1. /*
  2.  * Get the defined charging animation version
  3.  *
  4.  */
  5. void sync_anim_version()
  6. {
  7.     dprintf(INFO, "[lk logo: %s %d]\n",__FUNCTION__,__LINE__);
  9. #ifdef ANIMATION_NEW
  10.     show_animationm_ver = VERION_NEW_ANIMATION;
  11. #else
  12.     show_animationm_ver = VERION_OLD_ANIMATION;
  13.     dprintf(INFO, "[lk logo %s %d]not define ANIMATION_NEW:show old animation \n",__FUNCTION__,__LINE__);
  14. #endif
  16. }

而宏定义ANIMATION_NEW是在文件vendor/mediatek/proprietary/external/libshowlogo/cust_display.h中定义的。也就是说如果定义了字段ANIMATION_NEW，则使用fill_animation_battery_new动画，否则使用fill_animation_battery_old。不管使用哪个充电动画效果，2个方法都需要使用图片组合来达到动画的效果，而图片的存放位置在一个名为logo的文件加中。名为logo的文件夹可能会比较多，具体使用哪个文件夹中的图片需要根据具体编译的项目决定，同时在device/jrdcsh[project]/ProjectConfig.mk文件中，看到BOOT_LOGO = fhd;LCM_HEIGHT =1920;LCM_WIDTH=1080;这3个字段，分别表示存放logo图片的文件加名以及手机所用屏幕分辨率。如果需要客制化这些图片，需要用新logo图片替换掉原图片。（最开始做的时候没找对路径所以替换图片后还是没有效果，主要是许多公司都会对基线代码添加定制值，项目最终使用的是定制化代码中fhd文件中的logo图标，所以一定要找对logo图标存储的文件夹再替换）。fill_animation_battery_new方法和fill_animation_battery_old方法使用到的图片共40张。

  • 低电量充电显示的动画是由[fhd_bat_10_01.bmp~ fhd_bat_10_01.bmp]这10张静态图片组成，针对verion 1.

  • 充电背景图片[fhd_bat_bg.bmp] 共1张，针对verion 1.

  • 正常充电填充图片[fhd_bat_img.bmp] 共1张，针对verion 1.

  • 充电时动画显示是由[fhd_bat_animation_01.bmp~ fhd_bat_animation_10.bmp] 这10张静态图片组成，针对verion 1.

  • 数字图片[fhd_num_0.bmp~ fhd_num_9.bmp]共10张，，针对verion 1.

  • 百分比图片[fhd_mun_percent.bmp] 共1张 ，针对verion 1.

  • 100%电量图[fhd_bat_100.bmp] 共1张 ，针对verion 1.

  • 低电量图片[fhd_low_battery.bmp] 共1张 ，未见过此情况 。

  • 过电压图片[fhd_change_ov.bmp] 共1张，未见过此情况 。

  • 电压过低的图片[fhd_low_voltage.bmp] 共1张，未见过此情况 。

  • Kernel图片[fhd_kernal.bmp] 共1张 ,

  • 关机插入充电器显示第一张图片[fhd_uboot.bmp] 共1张 ,mt_disp_show_boot_logo();方法调用，入口函数为platform_init();

  • 图片fhd_battery[fhd_battery.bmp]共1张，由方法fill_animation_battery_old调用，针对verion 0。

而这些图片都由脚本vendor/jrdcom/build/common/update_logo.sh打包为一个文件，脚本具体如下。

  1. #!/bin/bash
  2. if [ "$1" = "" ]; then
  3.     echo "Please input resolution,"
  4.     echo "Such as: qvga, wqvga, wvga, hvga"
  5.     exit
  6. fi
  7. p=${1}
  8. product_path=${2}
  9. logo_path=${3}
  10. output_path=${4}
  11. boot_logo=${5}
  12. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp0.raw ${logo_path}/$p/"${boot_logo}_uboot".bmp
  13. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp1.raw ${logo_path}/$p/"${boot_logo}_battery".bmp
  14. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp2.raw ${logo_path}/$p/"${boot_logo}_low_battery".bmp
  15. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp3.raw ${logo_path}/$p/"${boot_logo}_charger_ov".bmp
  16. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp4.raw ${logo_path}/$p/"${boot_logo}_num_0".bmp
  17. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp5.raw ${logo_path}/$p/"${boot_logo}_num_1".bmp
  18. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp6.raw ${logo_path}/$p/"${boot_logo}_num_2".bmp
  19. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp7.raw ${logo_path}/$p/"${boot_logo}_num_3".bmp
  20. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp8.raw ${logo_path}/$p/"${boot_logo}_num_4".bmp
  21. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp9.raw ${logo_path}/$p/"${boot_logo}_num_5".bmp
  22. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp10.raw ${logo_path}/$p/"${boot_logo}_num_6".bmp
  23. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp11.raw ${logo_path}/$p/"${boot_logo}_num_7".bmp
  24. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp12.raw ${logo_path}/$p/"${boot_logo}_num_8".bmp
  25. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp13.raw ${logo_path}/$p/"${boot_logo}_num_9".bmp
  26. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp14.raw ${logo_path}/$p/"${boot_logo}_num_percent".bmp
  27. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp15.raw ${logo_path}/$p/"${boot_logo}_bat_animation_01".bmp
  28. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp16.raw ${logo_path}/$p/"${boot_logo}_bat_animation_02".bmp
  29. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp17.raw ${logo_path}/$p/"${boot_logo}_bat_animation_03".bmp
  30. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp18.raw ${logo_path}/$p/"${boot_logo}_bat_animation_04".bmp
  31. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp19.raw ${logo_path}/$p/"${boot_logo}_bat_animation_05".bmp
  32. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp20.raw ${logo_path}/$p/"${boot_logo}_bat_animation_06".bmp
  33. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp21.raw ${logo_path}/$p/"${boot_logo}_bat_animation_07".bmp
  34. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp22.raw ${logo_path}/$p/"${boot_logo}_bat_animation_08".bmp
  35. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp23.raw ${logo_path}/$p/"${boot_logo}_bat_animation_09".bmp
  36. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp24.raw ${logo_path}/$p/"${boot_logo}_bat_animation_10".bmp
  37. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp25.raw ${logo_path}/$p/"${boot_logo}_bat_10_01".bmp
  38. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp26.raw ${logo_path}/$p/"${boot_logo}_bat_10_02".bmp
  39. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp27.raw ${logo_path}/$p/"${boot_logo}_bat_10_03".bmp
  40. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp28.raw ${logo_path}/$p/"${boot_logo}_bat_10_04".bmp
  41. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp29.raw ${logo_path}/$p/"${boot_logo}_bat_10_05".bmp
  42. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp30.raw ${logo_path}/$p/"${boot_logo}_bat_10_06".bmp
  43. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp31.raw ${logo_path}/$p/"${boot_logo}_bat_10_07".bmp
  44. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp32.raw ${logo_path}/$p/"${boot_logo}_bat_10_08".bmp
  45. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp33.raw ${logo_path}/$p/"${boot_logo}_bat_10_09".bmp
  46. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp34.raw ${logo_path}/$p/"${boot_logo}_bat_10_10".bmp
  47. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp35.raw ${logo_path}/$p/"${boot_logo}_bat_bg".bmp
  48. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp36.raw ${logo_path}/$p/"${boot_logo}_bat_img".bmp
  49. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp37.raw ${logo_path}/$p/"${boot_logo}_bat_100_".bmp
  50. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp38.raw ${logo_path}/$p/"${boot_logo}_kernel".bmp
  51. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp39.raw ${logo_path}/$p/"${boot_logo}_low_voltage".bmp
  53. ${product_path}/vendor/jrdcom/build/jrdtools/zpipe -l 9 ${output_path}/"${p}".raw ${output_path}/temp0.raw ${output_path}/temp1.raw ${output_path}/temp2.raw ${output_path}/temp3.raw ${output_path}/temp4.raw ${output_path}/temp5.raw ${output_path}/temp6.raw ${output_path}/temp7.raw ${output_path}/temp8.raw ${output_path}/temp9.raw ${output_path}/temp10.raw ${output_path}/temp11.raw ${output_path}/temp12.raw ${output_path}/temp13.raw ${output_path}/temp14.raw ${output_path}/temp15.raw ${output_path}/temp16.raw ${output_path}/temp17.raw ${output_path}/temp18.raw ${output_path}/temp19.raw ${output_path}/temp20.raw ${output_path}/temp21.raw ${output_path}/temp22.raw ${output_path}/temp23.raw ${output_path}/temp24.raw ${output_path}/temp25.raw ${output_path}/temp26.raw ${output_path}/temp27.raw ${output_path}/temp28.raw ${output_path}/temp29.raw ${output_path}/temp30.raw ${output_path}/temp31.raw ${output_path}/temp32.raw ${output_path}/temp33.raw ${output_path}/temp34.raw ${output_path}/temp35.raw ${output_path}/temp36.raw ${output_path}/temp37.raw ${output_path}/temp38.raw ${output_path}/temp39.raw
  54. rm -rf ${output_path}/temp0.raw ${output_path}/temp1.raw ${output_path}/temp2.raw ${output_path}/temp3.raw ${output_path}/temp4.raw ${output_path}/temp5.raw ${output_path}/temp6.raw ${output_path}/temp7.raw ${output_path}/temp8.raw ${output_path}/temp9.raw ${output_path}/temp10.raw ${output_path}/temp11.raw ${output_path}/temp12.raw ${output_path}/temp13.raw ${output_path}/temp14.raw ${output_path}/temp15.raw ${output_path}/temp16.raw ${output_path}/temp17.raw ${output_path}/temp18.raw ${output_path}/temp19.raw ${output_path}/temp20.raw ${output_path}/temp21.raw ${output_path}/temp22.raw ${output_path}/temp23.raw ${output_path}/temp24.raw ${output_path}/temp25.raw ${output_path}/temp26.raw ${output_path}/temp27.raw ${output_path}/temp28.raw ${output_path}/temp29.raw ${output_path}/temp30.raw ${output_path}/temp31.raw ${output_path}/temp32.raw ${output_path}/temp33.raw ${output_path}/temp34.raw ${output_path}/temp35.raw ${output_path}/temp36.raw ${output_path}/temp37.raw ${output_path}/temp38.raw ${output_path}/temp39.raw
  55. echo "conversion finished"

而这些图片被打包后如何使用呢？在文件vendor/mediatek/proprietary/external/libshowlogo/cust_display.h中，会把图片序号定义为宏，在代码中通过这些宏来调用指定图片。

  1. #ifndef __CUST_DISPLAY_H__
  2. #define __CUST_DISPLAY_H__
  3. /*  change*/
  4. // color                       #00FF00  #ffffff
  5. #define BAR_OCCUPIED_COLOR  (0xFF7ED321)    // Green
  6. #define BAR_EMPTY_COLOR     (0xFF000000)    // White
  7. #define BAR_BG_COLOR        (0xFF000000)    // Black
  8. /*  change*/
  9. // LOGO number
  10. #define ANIM_V0_LOGO_NUM   5            // version 0: show 4 recatangle growing animation without battery number
  11. #define ANIM_V1_LOGO_NUM   39           // version 1: show wave animation with  battery number 
  12. #define ANIM_V2_LOGO_NUM   86           // version 2: show wireless charging animation      
  14. // Common LOGO index
  15. #define BOOT_LOGO_INDEX   0 
  16. #define KERNEL_LOGO_INDEX   38 
  18. #define ANIM_V0_BACKGROUND_INDEX   1 
  19. /*  change*/
  20. #define SHOW_BO_POWER   34
  21. /*  change*/
  22. #define ANIM_V1_BACKGROUND_INDEX   35
  25. #define LOW_BATTERY_INDEX   2 
  26. #define CHARGER_OV_INDEX   3 
  27. #define FULL_BATTERY_INDEX   37 
  29. // version 1: show wave animation with  battery number 
  31. // NUMBER LOGO INDEX
  32. #define NUMBER_PIC_START_0   4 
  33. #define NUMBER_PIC_PERCENT   14 
  35. // DYNAMIC ANIMATION LOGO INDEX
  36. #define BAT_ANIM_START_0   15 
  38. // LOW BATTERY(0~10%) ANIMATION LOGO
  39. #define LOW_BAT_ANIM_START_0    25 
  41. #define ANIM_LINE_INDEX   36 
  43. // version 2: show wireless charging animation logo index
  45. #define V2_NUM_START_0_INDEX  57  
  46. #define V2_NUM_PERCENT_INDEX  67 
  48. #define V2_BAT_0_10_START_INDEX     68  
  49. #define V2_BAT_10_40_START_INDEX    72 
  50. #define V2_BAT_40_80_START_INDEX    76 
  51. #define V2_BAT_80_100_START_NDEX   80
  53. #define V2_BAT_0_INDEX   84
  54. #define V2_BAT_100_INDEX   85
  56. // show fast charging animation logo index
  58. #define FAST_CHARGING_BAT_100_INDEX   39
  59. #define FAST_CHARGING_BAT_START_0_INDEX   40
  61. #define FAST_CHARGING_NUM_START_0_INDEX   46
  62. #define FAST_CHARGING_NUM_PERCENT_INDEX   56
  64. #if defined(FHD) || defined(CU_FHD) || defined(CMCC_FHD) || defined(CT_FHD) || defined(CMCC_LTE_FHD) || defined(CT_LTE_FHD) || defined(CU_LTE_FHD)
  65.     // fhd 1080*1920
  66.     // battery capacity rectangle
  67.     #define CAPACITY_LEFT                (387) // battery capacity center
  68.     #define CAPACITY_TOP                 (802)
  69.     #define CAPACITY_RIGHT               (691)
  70.     #define CAPACITY_BOTTOM              (1292)
  71.     /*  change*/
  72.     // first number rectangle
  73.     #define NUMBER_LEFT                  (512) // number
  74.     #define NUMBER_TOP                   (1097)
  75.     #define NUMBER_RIGHT                 (540)
  76.     #define NUMBER_BOTTOM                (1137)
  77.     /*  change*/
  78.     // %  rectangle
  79.     #define PERCENT_LEFT                 (568) // percent number_left + 2*number_width
  80.     #define PERCENT_TOP                  (1110)
  81.     #define PERCENT_RIGHT                (592)
  82.     #define PERCENT_BOTTOM               (1137)
  83.     /*  change*/
  84.     // top animation part
  85.     #define TOP_ANIMATION_LEFT           (387) // top animation
  86.     #define TOP_ANIMATION_TOP            (100)
  87.     #define TOP_ANIMATION_RIGHT          (691)
  88.     #define TOP_ANIMATION_BOTTOM         (152)
  89.     /*  change*/
  90.     // for old animation
  91.     #define BAR_LEFT            (463)
  92.     #define BAR_TOP             (760)
  93.     #define BAR_RIGHT           (619)
  94.     #define BAR_BOTTOM          (1049)
  95.     /*  change*/
  96. #elif defined(WQHD) || defined(CU_WQHD) || defined(CMCC_WQHD) || defined(CT_WQHD) || defined(CMCC_LTE_WQHD) || defined(CT_LTE_WQHD) || defined(CU_LTE_WQHD)
  97.     // wqhd 1440*2560
  99.     // battery capacity rectangle
  100.     #define CAPACITY_LEFT                (556) // battery capacity center
  101.     #define CAPACITY_TOP                 (1112)
  102.     #define CAPACITY_RIGHT               (882)
  103.     #define CAPACITY_BOTTOM              (1630)
  105.     // first number rectangle
  106.     #define NUMBER_LEFT                  (570) // number
  107.     #define NUMBER_TOP                   (770)
  108.     #define NUMBER_RIGHT                 (660)
  109.     #define NUMBER_BOTTOM                (898)
  111.     // %  rectangle
  112.     #define PERCENT_LEFT                 (750) // percent number_left + 2*number_width
  113.     #define PERCENT_TOP                  (770)
  114.     #define PERCENT_RIGHT                (864)
  115.     #define PERCENT_BOTTOM               (898)
  117.     // top animation part
  118.     #define TOP_ANIMATION_LEFT           (556) // top animation
  119.     #define TOP_ANIMATION_TOP            (100)
  120.     #define TOP_ANIMATION_RIGHT          (882)
  121.     #define TOP_ANIMATION_BOTTOM         (158)
  123.     // for old animation
  124.     #define BAR_LEFT            (443)
  125.     #define BAR_TOP             (337)
  126.     #define BAR_RIGHT           (574)
  127.     #define BAR_BOTTOM          (641)
  129. #elif defined(HD720) || defined(CU_HD720) || defined(CMCC_HD720) || defined(CT_HD720) || defined(CMCC_LTE_HD720) || defined(CT_LTE_HD720) || defined(CU_LTE_HD720)
  130.     // hd720 720*1280
  132.     // battery capacity rectangle
  133.     #define CAPACITY_LEFT                (278) // battery capacity center
  134.     #define CAPACITY_TOP                 (556)
  135.     #define CAPACITY_RIGHT               (441)
  136.     #define CAPACITY_BOTTOM              (817)
  138.     // first number rectangle
  139.     #define NUMBER_LEFT                  (290) // number
  140.     #define NUMBER_TOP                   (386)
  141.     #define NUMBER_RIGHT                 (335)
  142.     #define NUMBER_BOTTOM                (450)
  144.     // %  rectangle
  145.     #define PERCENT_LEFT                 (380) // percent number_left + 2*number_width
  146.     #define PERCENT_TOP                  (386)
  147.     #define PERCENT_RIGHT                (437)
  148.     #define PERCENT_BOTTOM               (450)
  150.     // top animation part
  151.     #define TOP_ANIMATION_LEFT           (278) // top animation
  152.     #define TOP_ANIMATION_TOP            (100)
  153.     #define TOP_ANIMATION_RIGHT          (441)
  154.     #define TOP_ANIMATION_BOTTOM         (129)
  156.     // for old animation
  157.     #define BAR_LEFT            (313)
  158.     #define BAR_TOP             (238)
  159.     #define BAR_RIGHT           (406)
  160.     #define BAR_BOTTOM          (453)

同时，在这个文件中还定义了各个图片在屏幕上的坐标位置，以fhd 1080*1920这个屏幕为例，手机屏幕左上角的坐标为(0,0)(是以一个像素为一个单位来计的)右下角的坐标为(1080,1920)。

  • battery capacity rectangle –表示电池电量图像的坐标，针对verion 1.
  • first number rectangle – 表示电池电量值十位数上数字的坐标，针对verion 1.
  • % rectangle – 表示电池电量值百分号的坐标，针对verion 1.
  • top animation part – 表示电池充电时波浪状动画的坐标，针对verion 1.
  • for old animation – 表示电池电量图像的坐标，针对verion 0.
    如果想修改各个图片在屏幕上的位置，只需要调整对应坐标即可。
  1. #if defined(FHD) || defined(CU_FHD) || defined(CMCC_FHD) || defined(CT_FHD) || defined(CMCC_LTE_FHD) || defined(CT_LTE_FHD) || defined(CU_LTE_FHD)
  2.     // fhd 1080*1920
  4.     // battery capacity rectangle
  5.     #define CAPACITY_LEFT                (387) // battery capacity center
  6.     #define CAPACITY_TOP                 (802)
  7.     #define CAPACITY_RIGHT               (691)
  8.     #define CAPACITY_BOTTOM              (1292)
  9.     // first number rectangle
  10.     #define NUMBER_LEFT                  (512) // number
  11.     #define NUMBER_TOP                   (1097)
  12.     #define NUMBER_RIGHT                 (540)
  13.     #define NUMBER_BOTTOM                (1137)
  14.     // %  rectangle
  15.     #define PERCENT_LEFT                 (568) // percent number_left + 2*number_width
  16.     #define PERCENT_TOP                  (1110)
  17.     #define PERCENT_RIGHT                (592)
  18.     #define PERCENT_BOTTOM               (1137)
  19.     // top animation part
  20.     #define TOP_ANIMATION_LEFT           (387) // top animation
  21.     #define TOP_ANIMATION_TOP            (100)
  22.     #define TOP_ANIMATION_RIGHT          (691)
  23.     #define TOP_ANIMATION_BOTTOM         (152)
  24.     // for old animation
  25.     #define BAR_LEFT            (463)
  26.     #define BAR_TOP             (760)
  27.     #define BAR_RIGHT           (619)
  28.     #define BAR_BOTTOM          (1049)

6.6 fill_animation_battery_new()与fill_animation_battery_old

接下来分别查看fill_animation_battery_new()与fill_animation_battery_old这2个函数的具体逻辑。

  • 首先，是fill_animation_battery_new函数，正如前面所说，该函数的动画效果是显示波浪状充电效果和电池电量白百分比(version 1: show wave animation with battery number)。
    在该方法中分别设定0~10%、10~90%、90~100%、100%等4个电量显示效果。
    0~10%为低电量效果：显示的大概是图片[fhd_bat_10_01.bmp~ fhd_bat_10_01.bmp]共10张轮流播放效果。
    10~90%为正常充电效果：显示由图片[fhd_bat_bg.bmp] 为背景，图片[fhd_bat_img.bmp]填充实际电量，图片[fhd_bat_animation_01.bmp~ fhd_bat_animation_10.bmp] 共10张显示动画效果3部分组成。
    90~100%正常充电效果：显示由图片[fhd_bat_bg.bmp] 为背景，图片[fhd_bat_img.bmp]填充实际电量，无动画效果，由前面2部分组成。
    100%电量效果：由图[fhd_bat_100.bmp] 共1张表示。
  1. /*change*/
  2. /*
  3.  * Show new charging animation
  4.  *
  5.  */
  6. void fill_animation_battery_new(int capacity, void *fill_addr, void * dec_logo_addr, void * logo_addr, LCM_SCREEN_T phical_screen)
  7. {
  8.     if (MTK_LOG_ENABLE == 1) {
  9.         SLOGD("[show_animation_common: %s %d]capacity : %d\n",__FUNCTION__,__LINE__, capacity);
  10.     }
  12.     if (capacity >= 100) {
  13.         //show_logo(37); // battery 100
  14.         fill_animation_logo(FULL_BATTERY_INDEX, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  16.     } else if (capacity < 10) {
  17.         if (MTK_LOG_ENABLE == 1) {
  18.             SLOGD("[show_animation_common: %s %d]charging_low_index = %d\n",__FUNCTION__,__LINE__, charging_low_index);
  19.         }
  20.         //通过charging_low_index++来循环显示低电量的10张图片
  21.         charging_low_index ++ ;
  22.         fill_animation_logo(LOW_BAT_ANIM_START_0 + charging_low_index, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  23.         //显示电量值上个位数的值
  24.         fill_animation_number(NUMBER_PIC_START_0 + capacity, 1, fill_addr, logo_addr, phical_screen);
  25.         fill_animation_dynamic(NUMBER_PIC_PERCENT, percent_location_rect, fill_addr, percent_pic_addr, logo_addr, phical_screen);
  27.         if (charging_low_index >= 9) charging_low_index = 0;
  29.     } else {
  31.         unsigned int capacity_grids = 0;
  32.         //static RECT_REGION_T battery_rect = {CAPACITY_LEFT,CAPACITY_TOP,CAPACITY_RIGHT,CAPACITY_BOTTOM};
  33.         /*把电池分成100等分，然后计算当前电量所占比重（因为背景图片已近画了10%电量，所以这里有capacity - 10这个操作）*/
  34.         capacity_grids = CAPACITY_BOTTOM - (CAPACITY_BOTTOM - CAPACITY_TOP) * (capacity - 10) / 90;
  36.         if (MTK_LOG_ENABLE == 1) {
  37.             SLOGD("[show_animation_common: %s %d]capacity_grids : %d,charging_animation_index = %d\n"
  38.                      ,__FUNCTION__,__LINE__, capacity_grids,charging_animation_index);
  39.         }
  40.         //background，即充电时的背景图片fhd_bat_bg.bmp，在该图中已经画出了10%电量
  41.         fill_animation_logo(ANIM_V1_BACKGROUND_INDEX, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  42.          //画出当前电池对应的电量
  43.         fill_animation_line(ANIM_LINE_INDEX, capacity_grids, fill_addr,  logo_addr, phical_screen);
  44.         fill_animation_number(NUMBER_PIC_START_0 + (capacity/10), 0, fill_addr, logo_addr, phical_screen);
  45.         fill_animation_number(NUMBER_PIC_START_0 + (capacity%10), 1, fill_addr, logo_addr, phical_screen);
  46.         fill_animation_dynamic(NUMBER_PIC_PERCENT, percent_location_rect, fill_addr, percent_pic_addr, logo_addr, phical_screen);
  47.         //如果电量小于90%，加上充电动画效果
  48.          if (capacity <= 90)
  49.          {
  50.             RECT_REGION_T top_animation_rect = {TOP_ANIMATION_LEFT, capacity_grids - (TOP_ANIMATION_BOTTOM - TOP_ANIMATION_TOP), TOP_ANIMATION_RIGHT, capacity_grids};
  51.             //top_animation_rect.bottom = capacity_grids;
  52.             //top_animation_rect.top = capacity_grids - top_animation_height;
  53.             charging_animation_index++;
  54.             //show_animation_dynamic(15 + charging_animation_index, top_animation_rect, top_animation_addr);
  55.             fill_animation_dynamic(BAT_ANIM_START_0 + charging_animation_index, top_animation_rect, fill_addr,
  56.                             top_animation_addr, logo_addr, phical_screen);
  57.             if (charging_animation_index >= 9) charging_animation_index = 0;
  58.          }
  59.     }
  60. }
  • 然后，是fill_animation_battery_old函数，该函数的动画是4格滚动的动画效果(version 0: show 4 recatangle growing animation without battery number),在该动画中使用图片fhd_battery.bmp充当背景图片，然后其他的4格电量都是通过函数fill_animation_prog_bar动态画出来的，fill_animation_battery_old函数具体实现如下。
  1. /*
  2.  *
  3.  * Show old charging animation
  4.  *
  5.  */
  6. void fill_animation_battery_old(int capacity,  void *fill_addr, void * dec_logo_addr, void * logo_addr,
  7.                        LCM_SCREEN_T phical_screen)
  8. {
  9.     int capacity_grids = 0;
  10.     if (capacity > 100) capacity = 100;
  11.     //这里表示计算当前电量占的比重，字段ANIM_V0_REGIONS表示把电池划分成几个格的电量
  12.     capacity_grids = (capacity * (ANIM_V0_REGIONS)) / 100;
  14.     if (version0_charging_index < capacity_grids * 2)
  15.         version0_charging_index = capacity_grids * 2;
  16.     if (capacity < 100){
  17.         version0_charging_index > 7? version0_charging_index = capacity_grids * 2 : version0_charging_index++;
  18.     } else {
  19.         version0_charging_index = ANIM_V0_REGIONS * 2;
  20.     }
  21.     //此处为显示背景图片fhd_battery.bmp的函数
  22.     fill_animation_logo(ANIM_V0_BACKGROUND_INDEX, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  23.     RECT_REGION_T rect_bar = {bar_rect.left + 1, bar_rect.top + 1, bar_rect.right, bar_rect.bottom};
  24.     //此处动态画出第0格到version0_charging_index/2格的电量
  25.     fill_animation_prog_bar(rect_bar,
  26.                        (unsigned int)(BAR_OCCUPIED_COLOR),
  27.                        0,  version0_charging_index/2,
  28.                        fill_addr, phical_screen);
  29.      /*此处动态画出第version0_charging_index/2格到ANIM_V0_REGIONS - version0_charging_index/2格的电量，与前面的函数交替使用就会出现4格电量滚动的效果(当然还需要在draw_thread_routine中不断while循环)*/
  30.     fill_animation_prog_bar(rect_bar,
  31.                       (unsigned int)(BAR_EMPTY_COLOR),
  32.                       version0_charging_index/2, ANIM_V0_REGIONS - version0_charging_index/2,
  33.                       fill_addr, phical_screen);
  34. }

接下老看看函数fill_animation_prog_bar的具体实现。

  1. /*
  2.  * Fill a rectangle size address with special color
  3.  *
  4.  */
  5. void fill_animation_prog_bar(RECT_REGION_T rect_bar,
  6.                        unsigned int fgColor,
  7.                        unsigned int start_div, unsigned int occupied_div,
  8.                        void *fill_addr, LCM_SCREEN_T phical_screen)
  9. {    //计算每一个格电量占多少像素
  10.     unsigned int div_size  = (rect_bar.bottom - rect_bar.top) / (ANIM_V0_REGIONS);
  11.     /*这是计算每格电量实际需要画多少像素的图像，字段ANIM_V0_SPACE_AFTER_REGION为各个电量格之间的空隙，如果为0则表示电量格之间无空隙*/
  12.     unsigned int draw_size = div_size - (ANIM_V0_SPACE_AFTER_REGION);
  13.     unsigned int i;
  14.     for (i = start_div; i < start_div + occupied_div; ++ i)
  15.     {
  16.         unsigned int draw_bottom = rect_bar.bottom - div_size * i - (ANIM_V0_SPACE_AFTER_REGION);
  17.         unsigned int draw_top    = draw_bottom - draw_size;
  18.         RECT_REGION_T rect = {rect_bar.left, draw_top, rect_bar.right, draw_bottom};
  19.          //这是函数才是真正进行电量格绘画的
  20.         fill_rect_with_color(fill_addr, rect, fgColor, phical_screen);
  21.     }
  22. }

7. 函数 key_control(pwrkeys, ARRAY_SIZE(pwrkeys));

这个函数从名字上看该是对按键进行控制的函数，推测该是检测power键是否被按下的，字段longPressDuration = 500;该是设定需要长按power的时间,函数long_press_control();会开启一个线程进行检测，当长按power达到指定时间，就会退出关机充电的线程然后设定bootingUp = true;估计会通过设定的bootingUp值来进行手机的重启操作，下面是key_control函数的具体实现。

  1. void key_control(int * pwrkeys, int pwrkeys_num)
  2. {
  3.     int res,i,j,k;
  4.     int pollres;
  5.     const char *device = NULL;
  6.     struct input_event event;
  7.     longPressDuration = 500;
  8.     long_press_control();
  9.     num_fds = 1;
  10.     ufds = (struct pollfd*)calloc(1, sizeof(ufds[0]));
  11.     ufds[0].fd = inotify_init();
  12.     ufds[0].events = POLLIN;
  13.     wd = inotify_add_watch(ufds[0].fd, INPUT_DEVICE_PATH, IN_DELETE | IN_CREATE);
  14.     if(wd < 0) {
  15.         KPOC_LOGI("could not add watch for %s, %s\n", INPUT_DEVICE_PATH, strerror(errno));
  16.         exit_charger(EXIT_ERROR_SHUTDOWN);
  17.     }
  18.     res = scan_dir(INPUT_DEVICE_PATH);
  19.     if(res < 0) {   
  20.         KPOC_LOGI("scan dir failed for %s\n", INPUT_DEVICE_PATH);
  21.         exit_charger(EXIT_ERROR_SHUTDOWN);
  22.     }
  23.     while(1) {
  24.         pollres = poll(ufds, num_fds, -1);
  25.         if(ufds[0].revents & POLLIN) {
  26.             read_notify(INPUT_DEVICE_PATH, ufds[0].fd);
  27.         }
  28.         for(i = 1; i < num_fds; i++) {
  29.             if(ufds[i].revents) {
  30.                 if(ufds[i].revents & POLLIN) {
  31.                     res = read(ufds[i].fd, &event, sizeof(event));
  32.                     if(res < (int)sizeof(event)) {
  33.                         KPOC_LOGI("could not get event\n");
  34.                         exit_charger(EXIT_ERROR_SHUTDOWN);
  35.                     }
  36. #ifdef VERBOSE_OUTPUT
  37.                     KPOC_LOGI("%s: event.type:%d,%d:%d\n", __FUNCTION__, event.type, event.code, event.value);
  38. #endif
  39.                     if (EV_KEY == event.type) {
  40.                         for (k=0; k<pwrkeys_num; k++) {
  41.                             if(event.code == pwrkeys[k]) {
  42.                                 if (1 == event.value) {
  43.                                     powerKeyPressed = true;
  44.                                     pthread_cond_signal(&keycond);
  45.                                 } else
  46.                                     powerKeyPressed = false;
  47.                                 break;
  48.                             }
  49.                         }
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.     }
  55. }

然后看看函数long_press_control()，在该函数中先对开启线程所需各种资源进行初始化，然后开启线程，线程开启后并不表示就进行重启操作了，它还要等待其他条件也满足才会重启，long_press_control函数的具体实现如下所示。

  1. void long_press_control()
  2. {
  3.     int ret = 0;
  4.     pthread_attr_t attr;
  5.     pthread_t pwrkey_thread;
  6.     pthread_mutex_init(&mutex, NULL);
  7.     pthread_cond_init(&keycond, NULL);
  8.     pthread_attr_init(&attr);
  9.    ret = pthread_create(&pwrkey_thread, &attr, key_thread_routine, NULL);
  10.     if (ret != 0)
  11.     {
  12.        KPOC_LOGI("create key pthread failed.\n");
  13.        exit_charger(EXIT_ERROR_SHUTDOWN);
  14.     }
  15. }

线程中的具体操作如下，先要判断powerKey是否被按下，而对powerKey是否被按下操作的检测是在函数key_control中实现的，当powerKey被按下则powerKeyPressed = true，在线程的实现函数中可以看到有2个while循环，最外层的while应该是循环等待powerKey被按下，达到要求会进入内层while进行计时等待的循环。

  1. static void* key_thread_routine(void *arg)
  2. {
  3.     static bool bootingUp = false;
  4.     static bool long_press = false;
  5.     struct timeval start;
  6.     while(1)
  7.     {
  8.         pthread_mutex_lock(&mutex);
  9.         pthread_cond_wait(&keycond, &mutex);
  10.         /* longPressDetecting = true; */
  11.         gettimeofday(&start, NULL);
  12.         KPOC_LOGI("pwr key long press check start\n");
  13.         while(powerKeyPressed)
  14.         {
  15.             usleep(1000*100); //200ms
  16.             long_press = time_exceed(start, longPressDuration);
  17.             if(long_press)
  18.             {
  19.                 KPOC_LOGI("pwr key reaches boot condition\n");
  20.                 if(get_voltage() > VBAT_POWER_ON)
  21.                 {
  22.                     showLowBattLogo = 0;
  23.                     // ready to boot up.
  24.                     inotify_rm_watch(ufds[0].fd, wd);
  25.                     if (keyDownPressed || keyUpPressed)
  26.                         exit_charger(EXIT_REBOOT_UBOOT);
  27.                     else
  28.                         exit_charger(EXIT_POWER_UP);
  29.                     bootingUp = true;
  30.                 }
  31.                 else {
  32.                     showLowBattLogo = 1;
  33.                     KPOC_LOGI("VBAT <= %d\n", VBAT_POWER_ON);
  34.                     break;
  35.                 }
  36.             }
  37.         }
  38.         if (!long_press)
  39.             showLowBattLogo = 0;
  40.         if(!bootingUp)
  41.             start_charging_anim(TRIGGER_ANIM_KEY);
  42.         KPOC_LOGI("pwr key long press check end\n");
  43.         pthread_mutex_unlock(&mutex);
  44.     }
  45.     return NULL;
  46. }

8. solution

进过上面的分析(当然很多都是猜测，分析也比较水)，就开始动手改代码，希望能够实现期望的效果。

8.1 图片替换

总共修改/增加共16张图片：

  • 数字图片0~9 需要替换成新风格的数字图片 共10张，直接替换
  • 百分号图片，需要替换成新风格的百分号图片 共1张，直接替换
  • 充电背景图片 需要替换成新风格的图片 共1张，直接替换
  • 低电量图片 需要替换成新风格的图片 共1张，直接替换
  • 低电压、高电压图片 需要替换成新风格的图片 共2张，直接替换
  • 无电量图片(这是新加的，要求电量小于等于0时显示) 1张，添加
    注被替换图片的位置一定要找对，不然就坑壁了，到时候效果出不来

8.2 修改vendor/mediatek/proprietary/external/charger/bootlogo.cpp文件

因为在显示充电动画之前，还需要先显示一张低电量图片，时长1秒钟。本来在插入充电器后，在启动lk/kernel会显示一个logo，本来想直接该这个logo的。但是发现从这个logo显示到开始播放充电动画之间间隔5~6秒钟，这当然不行，所以在开始播放充电动画前面加了个显示低电量图片时长1秒钟的逻辑，也不知道这样搞会不会被叼。先不管，改了看看效果再说，具体修改如下。

  1. /*
  2.  * Show charging animation with battery capacity
  3.  *
  4.  */
  5. void bootlogo_show_charging(int capacity, int cnt)
  6. {
  7.     KPOC_LOGI("[ChargingAnimation: %s %d]%d, %d",__FUNCTION__,__LINE__, capacity, cnt);
  9.     if (get_battnotify_status())
  10.     {
  11.         KPOC_LOGI("[ChargingAnimation: %s %d] show_charger_error_logo, get_battnotify_status()= %d \n",__FUNCTION__,__LINE__, get_battnotify_status());
  12.         show_charger_ov_logo();
  13.         return;
  14.     }
  15.     if (showLowBattLogo)
  16.     {
  17.         KPOC_LOGI("[ChargingAnimation: %s %d] show_low_battery , showLowBattLogo = %d \n",__FUNCTION__,__LINE__,showLowBattLogo);
  18.         show_low_battery();
  19.         return;
  20.     }
  21. /*change*/
  22. //字段show_low_battery_one_time在前面还需要定义下，不然编译报错
  23.     if(show_low_battery_one_time)
  24.     {    //delay 1000ms
  25.     show_low_battery();
  26.     usleep(1000*1000);
  27.     show_low_battery_one_time=0;
  28.     }
  29. /*change*/
  30.     show_battery_capacity(capacity);
  31. }

8.3 修改vendor/jrdcom/build/common/update_logo.sh文件

这个文件就是对图片进行打包成raw文件的脚本，因为前面添加一张无电量图片，所以也要在这个文件中添加，不然只在logo目录中添加是没用的，修改如下。

  1. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp29.raw ${logo_path}/$p/"${boot_logo}_bat_10_05".bmp
  2. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp30.raw ${logo_path}/$p/"${boot_logo}_bat_10_06".bmp
  3. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp31.raw ${logo_path}/$p/"${boot_logo}_bat_10_07".bmp
  4. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp32.raw ${logo_path}/$p/"${boot_logo}_bat_10_08".bmp
  5. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp33.raw ${logo_path}/$p/"${boot_logo}_bat_10_09".bmp
  6. #change 直接在原来低电量图片上改的，反正低电量效果不需要了
  7. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp34.raw ${logo_path}/$p/"${boot_logo}_no_power".bmp
  8. #change
  9. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp35.raw ${logo_path}/$p/"${boot_logo}_bat_bg".bmp
  10. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp36.raw ${logo_path}/$p/"${boot_logo}_bat_img".bmp
  11. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp37.raw ${logo_path}/$p/"${boot_logo}_bat_100".bmp
  12. ${product_path}/vendor/jrdcom/build/jrdtools/bmp_to_raw ${output_path}/temp38.raw ${logo_path}/$p/"${boot_logo}_kernel".bmp

8.4 修改vendor/mediatek/proprietary/external/libshowlogo/cust_display.h文件

修改这个文件主要是调整新充电样式中电池电量、电量值、百分号的位置(坑爹的UE不给具体坐标，就说按设计文档上搞，卧槽真是被狗咬了一口的感觉，文档上根本不是写的很清楚，坐标也是用GD表示的，没办法只能慢慢调了)，电池电量的颜色还有就是添加无电量图片的宏定义，具体修改如下。

  1. /*change*/
  2. // color                       #00FF00  #ffffff
  3. #define BAR_OCCUPIED_COLOR  (0xFF7ED321)    // Green
  4. #define BAR_EMPTY_COLOR     (0xFF000000)    // Black
  5. #define BAR_BG_COLOR        (0xFF000000)    // Black
  6. #define SHOW_NO_POWER   34   //这个是无电量图片对应的序号
  7. // first number rectangle
  8.     #define NUMBER_LEFT                  (512) // number
  9.     #define NUMBER_TOP                   (1097)
  10.     #define NUMBER_RIGHT                 (540)
  11.     #define NUMBER_BOTTOM                (1137)
  13.     // %  rectangle
  14.     #define PERCENT_LEFT                 (568) // percent number_left + 2*number_width
  15.     #define PERCENT_TOP                  (1110)
  16.     #define PERCENT_RIGHT                (592)
  17.     #define PERCENT_BOTTOM               (1137)
  19.     // top animation part
  20.     #define TOP_ANIMATION_LEFT           (387) // top animation
  21.     #define TOP_ANIMATION_TOP            (100)
  22.     #define TOP_ANIMATION_RIGHT          (691)
  23.     #define TOP_ANIMATION_BOTTOM         (152)
  25.     // for old animation
  26.     #define BAR_LEFT            (465)
  27.     #define BAR_TOP             (773)
  28.     #define BAR_RIGHT           (616)
  29.     #define BAR_BOTTOM          (1048)
  30. /*change*/

8.5 修改vendor/mediatek/proprietary/external/libshowlogo/show_animation_common.h文件

修改这个文件主要是调整电池电量的格数，原来是4个格，而且每个格之间有间隙，需要弄成5个格，每个格之间无间隙，只需要修改2个宏，具体修改如下。

  1. /*change*/
  2. // version_0 animation
  3. #define ANIM_V0_REGIONS  5
  4. #define ANIM_V0_SPACE_AFTER_REGION  0
  5. /*change*/

8.6 修改vendor/mediatek/proprietary/external/libshowlogo/show_animation_common.c文件

这个文件主要修改函数void fill_animation_battery_old，因为这个函数的功能就是实现4格滚动效果，所以直接在它上面改。

  • 原本没有显示电池电量值，所以需要添加
  • 需要设置90%后无动画
  • 需要设置电量小于等于0显示SHOW_NO_POWER图片

具体的修改如下所示。

  1. /*
  2.  * Show old charging animation
  3.  *
  4.  */
  5. void fill_animation_battery_old(int capacity,  void *fill_addr, void * dec_logo_addr, void * logo_addr,
  6.                        LCM_SCREEN_T phical_screen)
  7. {
  8.     int capacity_grids = 0;
  9.     if (capacity > 100) capacity = 100;
  10.     capacity_grids = (capacity * (ANIM_V0_REGIONS)) / 100;
  11. /*change*/
  12.     if (version0_charging_index < capacity_grids * 2)
  13.         version0_charging_index = capacity_grids * 2;
  14.     if (capacity < 100){
  15.     if(capacity < 90){
  16.         version0_charging_index > 9? version0_charging_index = capacity_grids * 2 : version0_charging_index++;
  17.     }else{
  18.     version0_charging_index > 7? version0_charging_index = capacity_grids * 2 : version0_charging_index++;
  19.     }
  20.     } else {
  21.         version0_charging_index = ANIM_V0_REGIONS * 2;
  22.     }
  23.     if(capacity>0)
  24.     {
  25.     fill_animation_logo(ANIM_V0_BACKGROUND_INDEX, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  26.     if (capacity < 10) {
  27.     fill_animation_number(NUMBER_PIC_START_0 + capacity, 1, fill_addr, logo_addr, phical_screen);
  28.         fill_animation_dynamic(NUMBER_PIC_PERCENT, percent_location_rect, fill_addr, percent_pic_addr, logo_addr, phical_screen);
  29.     }else{
  30.         if(capacity >=100){
  31.         fill_animation_number(NUMBER_PIC_START_0 + ((capacity%100)/10), 0, fill_addr, logo_addr, phical_screen);
  32.         fill_animation_number(NUMBER_PIC_START_0 + (capacity%10), 1, fill_addr, logo_addr, phical_screen);
  33.         fill_animation_number(NUMBER_PIC_START_0 + (capacity/100), -1, fill_addr, logo_addr, phical_screen);
  34.         fill_animation_dynamic(NUMBER_PIC_PERCENT, percent_location_rect, fill_addr, percent_pic_addr, logo_addr, phical_screen);
  35.         }else{
  36.         fill_animation_number(NUMBER_PIC_START_0 + (capacity/10), 0, fill_addr, logo_addr, phical_screen);
  37.         fill_animation_number(NUMBER_PIC_START_0 + (capacity%10), 1, fill_addr, logo_addr, phical_screen);
  38.         fill_animation_dynamic(NUMBER_PIC_PERCENT, percent_location_rect, fill_addr, percent_pic_addr, logo_addr, phical_screen);
  39.             }
  40.     }
  41.     RECT_REGION_T rect_bar = {bar_rect.left + 1, bar_rect.top + 1, bar_rect.right, bar_rect.bottom};
  42.     fill_animation_prog_bar(rect_bar,
  43.                        (unsigned int)(BAR_OCCUPIED_COLOR),
  44.                        0,  version0_charging_index/2,
  45.                        fill_addr, phical_screen);
  46.     fill_animation_prog_bar(rect_bar,
  47.                       (unsigned int)(BAR_EMPTY_COLOR),
  48.                       version0_charging_index/2, ANIM_V0_REGIONS - version0_charging_index/2,
  49.                       fill_addr, phical_screen);
  50.     }else{
  51.     fill_animation_logo(SHOW_NO_POWER, fill_addr, dec_logo_addr, logo_addr,phical_screen);
  52.     }
  53. }
  54. /*change*/

改完后编译发现是可以达到需求上面的要求(当然不是一下就编成功了的，都编了n次，而且每次编译都要费很长的时间，看来做事要细心，不然错了或者漏改了都会报错)，这样也算马马虎虎完成任务吧，最后就看设计的人是否觉得达到她期望效果，不然估计还要坑壁的继续改。

9. 总结

最开始做这个还真的不知道怎么入手，然后是各种找资料，当然网上也会有一些参考的例子，不过看了后也还是不是非常懂，主要是不理解关机充电在什么阶段开始的。并且对lk、kernel这些流程不是非常熟悉，只能慢慢尝试在图片上做标记，改不同的坐标来看编译出来是什么效果。最开始找到的就是fill_animation_battery_new这个函数，只知道是它实现的充电动画效果，还想就在这个函数上面改成5格滚动的动画效果。后面看到关机充电动画实现四格滚动动画问题分析才知道原来原版系统本来就有这个滚动的动画效果实现(要是对相关代码有个全局观估计就不会这么狼狈)，只要在它上修改其实就方便多了。同时，只要知道关机充电这个功能就是一个应用而已，它是由第一个进程init开启的，然后从这应用的入口函数vendor/mediatek/proprietary/external/charger/main.cpp中的main开始追，整个充电逻辑就会比较清楚了。
以上是个人对mtk关机充电部分的理解，应该会有一些错误和遗漏，欢迎批评指正！