Android——开机动画

最新推荐文章于 2024-06-05 14:04:19 发布
最新推荐文章于 2024-06-05 14:04:19 发布
阅读量2.9k 收藏 5
点赞数 1
分类专栏： 【Android — 机制】 文章标签： kernel init framebuffer SurfaceFlinger bootanimation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jscese/article/details/21162621
版权

          android系统的开机动画可分为三个部分，kernel启动，init进程启动，android系统服务启动。这三个开机动画都是在一个叫做 帧缓冲区（frame buffer）的硬件设备上进行渲染绘制的。

在Linux内核中，每一个硬件设备都有一个主设备号和一个从设备号，它们用来唯一地标识一个硬件设备。对于帧缓冲区硬件设备来说，它们的主设备号定义为FB_MAJOR（29），而从设备号则与注册的顺序有关，它们的值依次等于0，1，2等。

每一个被注册的帧缓冲区硬件设备在/dev/graphics目录下都有一个对应的设备文件fb<minor>，其中，<minor>表示一个从设备号。例如，第一个被注册的帧缓冲区硬件设备在/dev/graphics目录下都有一个对应的设备文件fb0。用户空间的应用程序通过这个

设备文件就可以操作帧缓冲区硬件设备了，即将要显示的画面渲染到帧缓冲区硬件设备上去


一.kernel启动动画：

kernel的启动画面在一般的android系统里面都是没有出现的，在kernel的config里面有这么两项： 

# CONFIG_FRAMEBUFFER_CONSOLE is not set
# CONFIG_LOGO is not set

我这里是没有打开的，第一个代表支持帧缓冲控制台，第二个代表显示logo。
在编译控制台的位置：
Device Drivers ---> Graphics support ---> Console display driver support ---> Framebuffer Console support
Device Drivers ---> Graphics support ---> Bootup logo

kernel中的ainimation 基本上都是在kernel/drivers/video/fbmem.c这个文件中实现。
我的kernel版本是： 
VERSION = 3
PATCHLEVEL = 1
SUBLEVEL = 10
EXTRAVERSION =
NAME = "Divemaster Edition"

通过一系列的初始化和准备，最后调用kernel/drivers/video/logo.c中的fb_find_logo（...）来保存kernel 动画的内容： 

const struct linux_logo * __init_refok fb_find_logo(int depth)
{
	const struct linux_logo *logo = NULL;

	if (nologo)
		return NULL;

	if (depth >= 1) {
#ifdef CONFIG_LOGO_LINUX_MONO
		/* Generic Linux logo */
		logo = &logo_linux_mono;
#endif
#ifdef CONFIG_LOGO_SUPERH_MONO
		/* SuperH Linux logo */
		logo = &logo_superh_mono;
#endif
	}
	
	if (depth >= 4) {
#ifdef CONFIG_LOGO_LINUX_VGA16
		/* Generic Linux logo */
		logo = &logo_linux_vga16;
#endif
#ifdef CONFIG_LOGO_BLACKFIN_VGA16
		/* Blackfin processor logo */
		logo = &logo_blackfin_vga16;
#endif
#ifdef CONFIG_LOGO_SUPERH_VGA16
		/* SuperH Linux logo */
		logo = &logo_superh_vga16;
#endif
	}
	
	if (depth >= 8) {
#ifdef CONFIG_LOGO_LINUX_CLUT224
		/* Generic Linux logo */
		logo = &logo_linux_clut224;
#endif
#ifdef CONFIG_LOGO_BLACKFIN_CLUT224
		/* Blackfin Linux logo */
		logo = &logo_blackfin_clut224;
#endif
#ifdef CONFIG_LOGO_DEC_CLUT224
		/* DEC Linux logo on MIPS/MIPS64 or ALPHA */
		logo = &logo_dec_clut224;
#endif
#ifdef CONFIG_LOGO_MAC_CLUT224
		/* Macintosh Linux logo on m68k */
		if (MACH_IS_MAC)
			logo = &logo_mac_clut224;
#endif
#ifdef CONFIG_LOGO_PARISC_CLUT224
		/* PA-RISC Linux logo */
		logo = &logo_parisc_clut224;
#endif
#ifdef CONFIG_LOGO_SGI_CLUT224
		/* SGI Linux logo on MIPS/MIPS64 and VISWS */
		logo = &logo_sgi_clut224;
#endif
#ifdef CONFIG_LOGO_SUN_CLUT224
		/* Sun Linux logo */
		logo = &logo_sun_clut224;
#endif
#ifdef CONFIG_LOGO_SUPERH_CLUT224
		/* SuperH Linux logo */
		logo = &logo_superh_clut224;
#endif
#ifdef CONFIG_LOGO_M32R_CLUT224
		/* M32R Linux logo */
		logo = &logo_m32r_clut224;
#endif
	}
	return logo;
}

这个函数帧缓冲区硬件设备的颜色深度depth，以及不同的编译选项来获取内容的指针。
在kernel/include/linux/linux_logo.h中定义了这些内容结构体： 
extern const struct linux_logo logo_linux_mono;
extern const struct linux_logo logo_linux_vga16;
extern const struct linux_logo logo_linux_clut224;
extern const struct linux_logo logo_blackfin_vga16;
extern const struct linux_logo logo_blackfin_clut224;
extern const struct linux_logo logo_dec_clut224;
extern const struct linux_logo logo_mac_clut224;
extern const struct linux_logo logo_parisc_clut224;
extern const struct linux_logo logo_sgi_clut224;
extern const struct linux_logo logo_sun_clut224;
extern const struct linux_logo logo_superh_mono;
extern const struct linux_logo logo_superh_vga16;
extern const struct linux_logo logo_superh_clut224;
extern const struct linux_logo logo_m32r_clut224;
extern const struct linux_logo logo_spe_clut224;

这些结构体变量保存kernel/drivers/video/logo/下的 ***.ppm 以及.pbm的文件内容。
通过logo指针保存了动画内容之后往后走就要来渲染了，调用到fbmem.c中的： 


int fb_show_logo(struct fb_info *info, int rotate)
{
	int y;

	y = fb_show_logo_line(info, rotate, fb_logo.logo, 0,
			      num_online_cpus());
	y = fb_show_extra_logos(info, y, rotate);

	return y;
}

同一个文件往下走调用到： 
static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
			    int rotate, unsigned int num)
{
	unsigned int x;

	if (rotate == FB_ROTATE_UR) {
		for (x = 0;
		     x < num && image->dx + image->width <= info->var.xres;
		     x++) {
			info->fbops->fb_imageblit(info, image);
			image->dx += image->width + 8;
		}
	} else if (rotate == FB_ROTATE_UD) {
		for (x = 0; x < num && image->dx >= 0; x++) {
			info->fbops->fb_imageblit(info, image);
			image->dx -= image->width + 8;
		}
	} else if (rotate == FB_ROTATE_CW) {
		for (x = 0;
		     x < num && image->dy + image->height <= info->var.yres;
		     x++) {
			info->fbops->fb_imageblit(info, image);
			image->dy += image->height + 8;
		}
	} else if (rotate == FB_ROTATE_CCW) {
		for (x = 0; x < num && image->dy >= 0; x++) {
			info->fbops->fb_imageblit(info, image);
			image->dy -= image->height + 8;
		}
	}
}
其中：
FB_ROTATE_UR  正常显示
FB_ROTATE_UD  上下倒置
FB_ROTATE_CW  顺时针转90度
FB_ROTATE_CCW  逆时针转90度
到这里就开始调用帧缓冲区硬件设备渲染指定的图像。



二.init进程启动动画：

init进程的启动又要从android下的/system/core/init/init.c的main函数开始了： 

int main(int argc, char **argv)
{
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;


if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);


if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
...
queue_builtin_action(console_init_action, "console_init");
...
}



这里会根据传进来的参数argv[0]判断进程名，因为首先启动的是init进程，之后会根据init.rc配置ueventd以及watchogd等进程，在这里，这两个进程加载的执行文件也是从这个init文件开始会以这个main函数为入口，所以加了判别。


在这里向init进程的action执行队列添加了一个console_init_action的action，init进程执行相应操作，具体可查看 http://blog.csdn.net/jscese/article/details/18700903，最后依次执行action队列，执行同文件下的： 

static int console_init_action(int nargs, char **args)
{
    int fd;
    char tmp[PROP_VALUE_MAX];

    if (console[0]) {
        snprintf(tmp, sizeof(tmp), "/dev/%s", console);
        console_name = strdup(tmp);
    }

    fd = open(console_name, O_RDWR);
    if (fd >= 0)
        have_console = 1;
    close(fd);

    if( load_565rle_image(INIT_IMAGE_FILE) ) {
        fd = open("/dev/tty0", O_WRONLY);
        if (fd >= 0) {
            const char *msg;
                msg = "\n"
            "\n"
            "\n"
            "\n"
            "\n"
            "\n"
            "\n"  // console is 40 cols x 30 lines
            "\n"
            "\n"
            "\n"
            "\n"
            "\n"
            "\n"
            "\n"
            "             A N D R O I D ";
            write(fd, msg, strlen(msg));
            close(fd);
        }
    }
    return 0;
}

初始化控制台，通过dev/console设备来访问控制台，如果有的话 have_console 全局变量被设置为1.
开始加载显示init进程的动画，通过load_565rle_image(INIT_IMAGE_FILE）函数，INIT_IMAGE_FILE 宏定义指定动画内容位置，定义在init.h中 
#define INIT_IMAGE_FILE	"/initlogo.rle"

实现在/system/core/init/logo.c中： 
int load_565rle_image(char *fn)
{
    struct FB fb;
    struct stat s;
    unsigned short *data, *bits, *ptr;
    unsigned count, max;
    int fd;

    if (vt_set_mode(1)) 
        return -1;

    fd = open(fn, O_RDONLY);
    if (fd < 0) {
        ERROR("cannot open '%s'\n", fn);
        goto fail_restore_text;
    }

    if (fstat(fd, &s) < 0) {
        goto fail_close_file;
    }

    data = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0);
    if (data == MAP_FAILED)
        goto fail_close_file;

    if (fb_open(&fb))
        goto fail_unmap_data;

    max = fb_width(&fb) * fb_height(&fb);
    ptr = data;
    count = s.st_size;
    bits = fb.bits;
    while (count > 3) {
        unsigned n = ptr[0];
        if (n > max)
            break;
        android_memset16(bits, ptr[1], n << 1);
        bits += n;
        max -= n;
        ptr += 2;
        count -= 4;
    }

    munmap(data, s.st_size);
    fb_update(&fb);
    fb_close(&fb);
    close(fd);
    unlink(fn);
    return 0;

fail_unmap_data:
    munmap(data, s.st_size);    
fail_close_file:
    close(fd);
fail_restore_text:
    vt_set_mode(0);
    return -1;
}

调用： 
static int vt_set_mode(int graphics)
{
    int fd, r;
    fd = open("/dev/tty0", O_RDWR | O_SYNC);
    if (fd < 0)
        return -1;
    r = ioctl(fd, KDSETMODE, (void*) (graphics ? KD_GRAPHICS : KD_TEXT));
    close(fd);
    return r;
}


打开控制控制台设备文件/dev/tty0，设置控制台的显示方式，传入参数为1，控制台将以图形方式显示。

往下就是打开传入的动画内容文件，fstat计算大小，通过mmap将 initlogo.rle内容映射到init进程地址空间，

再打开/dev/graphics/fb0，通过打开这个设备文件就可以访问帧缓冲区设备，获取帧缓冲区设备的固定信息和可变信息，然后映射到init进程地址空间，

获取屏幕的宽高，计算出帧缓冲区能写入的大小，就知道在init进程地址空间上的大小，通过一个while循环将initlogo.rle内容写入到帧缓冲区设备上去。

更新init进程开机画面到屏幕上面： 
static void fb_update(struct FB *fb)
{
    fb->vi.yoffset = 1;
    ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi);
    fb->vi.yoffset = 0;
    ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi);
}
通过帧缓冲区设备渲染。


三.系统服务启动动画：



这个动画是android系统最常用的一个动画，由bootainimation来负责显示运行，这在init.rc里面是作为一个service：

1.init.rc 配置：

service bootanim /system/bin/bootanimation
    class main
    user graphics
    group graphics
    disabled
    oneshot


这个是disabled，init启动解析的时候是不会被启动的。


2.SurfaceFinger服务的启动：

在前文 http://blog.csdn.net/jscese/article/details/17115395#t7 中启动到system server部分启动了系统所需的一些服务时，在 system_init.cpp中启动视频服务时会启动一个SurfaceFlinger的服务，获取一个SurfaceFinger的实例。
SurfaceFlinger类继承于BinderService模板类，BinderService类的instantiate()函数就是构造对应类型的服务对象，并注册到ServiceManager进程中/frameworks/native/include/binder/BinderService.h： 

   static void instantiate() { publish(); }
  static status_t publish(bool allowIsolated = false) {
        sp<IServiceManager> sm(defaultServiceManager());
        return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);
    }

调用到/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp中构造： 

SurfaceFlinger::SurfaceFlinger()
    :   BnSurfaceComposer(), Thread(false),
        mTransactionFlags(0),
        mTransactionPending(false),
        mAnimTransactionPending(false),
        mLayersRemoved(false),
        mRepaintEverything(0),
        mBootTime(systemTime()),
        mVisibleRegionsDirty(false),
        mHwWorkListDirty(false),
        mDebugRegion(0),
        mDebugDDMS(0),
        mDebugDisableHWC(0),
        mDebugDisableTransformHint(0),
        mDebugInSwapBuffers(0),
        mLastSwapBufferTime(0),
        mDebugInTransaction(0),
        mLastTransactionTime(0),
        mBootFinished(false)
{
    ALOGI("SurfaceFlinger is starting");

    // debugging stuff...
    char value[PROPERTY_VALUE_MAX];

    property_get("debug.sf.showupdates", value, "0");
    mDebugRegion = atoi(value);

    property_get("debug.sf.ddms", value, "0");
    mDebugDDMS = atoi(value);
    if (mDebugDDMS) {
        if (!startDdmConnection()) {
            // start failed, and DDMS debugging not enabled
            mDebugDDMS = 0;
        }
    }
    ALOGI_IF(mDebugRegion, "showupdates enabled");
    ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
}

这里的构造只是做了一些初始化，获取系统开机属性，设置一些变量。

因为SurfaceFlinger又继承于RefBase类，并重写了该类的onFirstRef()函数，我们知道，RefBase类的子类对象在第一次创建时，会自动调用onFirstRef()函数，因此在SurfaceFlinger对象构造完成时，将调用onFirstRef()函数。 
void SurfaceFlinger::onFirstRef()
{
    mEventQueue.init(this);

    run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);

    // Wait for the main thread to be done with its initialization
    mReadyToRunBarrier.wait();
}

这里就从SurfaceFlinger的父类Thread创建一个新的线程，加入threadLoop函数，调用到 readyToRun()函数： 
status_t SurfaceFlinger::readyToRun()
{
    ALOGI(  "SurfaceFlinger's main thread ready to run. "
            "Initializing graphics H/W...");


   ...

    //  initialize OpenGL ES
    DisplayDevice::makeCurrent(mEGLDisplay, hw, mEGLContext);
    initializeGL(mEGLDisplay);


    // start the EventThread
    mEventThread = new EventThread(this);
    mEventQueue.setEventThread(mEventThread);
...
    // start boot animation
    startBootAnim();


    return NO_ERROR;
}


3.SurfaceFinger中开启bootainimation服务：

开始执行bootainimation。 

void SurfaceFlinger::startBootAnim() {
    // start boot animation
    property_set("service.bootanim.exit", "0");
    property_set("ctl.start", "bootanim");
}

设置系统属性ctl.start 的值为bootanim。android的系统属性启动以及应用可以参考 http://blog.csdn.net/jscese/article/details/18700903。
到这里就启动了一个新的服务进程bootanim，/frameworks/base/cmds/bootanimation/bootanimation_main.cpp 


int main(int argc, char** argv)
{
#if defined(HAVE_PTHREADS)
    setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);
#endif

    char value[PROPERTY_VALUE_MAX];
    property_get("debug.sf.nobootanimation", value, "0");
    int noBootAnimation = atoi(value);
    ALOGI_IF(noBootAnimation,  "boot animation disabled");
    if (!noBootAnimation) {
       
        ALOGD("boot animation start");
       

        sp<ProcessState> proc(ProcessState::self());
        ProcessState::self()->startThreadPool();

        // create the boot animation object
        sp<BootAnimation> boot = new BootAnimation();

        IPCThreadState::self()->joinThreadPool();

    }
    return 0;
}

获取nobootanimation这个属性的值，判断如果为0的话
那么接下来就会启动一个Binder线程池，并且创建一个BootAnimation对象。这个BootAnimation对象就是用来显示第三个开机画面的。由于BootAnimation对象在显示第三个开机画面的过程中，需要与SurfaceFlinger服务通信，因此，应用程序BootAnimation就需要启动一个Binder线程池。
BootAnimation类间接地继承了RefBase类，并且重写了RefBase类的成员函数onFirstRef，
因此，当一个BootAnimation对象第一次被智能指针引用的时，这个BootAnimation对象的成员函数onFirstRef就会被调用/frameworks/base/cmds/bootanimation/BootAnimation.cpp： 
void BootAnimation::onFirstRef() {
    status_t err = mSession->linkToComposerDeath(this);
    ALOGE_IF(err, "linkToComposerDeath failed (%s) ", strerror(-err));
    if (err == NO_ERROR) {
        run("BootAnimation", PRIORITY_DISPLAY);
    }
}
同时构造： 
BootAnimation::BootAnimation() : Thread(false)
{
    mSession = new SurfaceComposerClient();
}

mSession是BootAnimation类的一个成员变量，它的类型为SurfaceComposerClient，是用来和SurfaceFlinger执行Binder进程间通信的。

4.bootanimation线程构建：

BootAnimation类继承了Thread类，因此，当BootAnimation类的成员函数onFirstRef调用了父类Thread的成员函数run之后，系统就会创建一个线程，这个线程在第一次运行之前，会调用BootAnimation类的成员函数readyToRun来执行一些初始化工作，后面再调用BootAnimation类的成员函数threadLoop来显示第三个开机画面： 


status_t BootAnimation::readyToRun() {
    mAssets.addDefaultAssets();


 ...


    mAndroidAnimation = true;

    // If the device has encryption turned on or is in process
    // of being encrypted we show the encrypted boot animation.
    char decrypt[PROPERTY_VALUE_MAX];
    property_get("vold.decrypt", decrypt, "");

    bool encryptedAnimation = atoi(decrypt) != 0 || !strcmp("trigger_restart_min_framework", decrypt);

    if ((encryptedAnimation &&
            (access(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE, R_OK) == 0) &&
            (mZip.open(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE) == NO_ERROR)) ||

            ((access(USER_BOOTANIMATION_FILE, R_OK) == 0) &&
            (mZip.open(USER_BOOTANIMATION_FILE) == NO_ERROR)) ||

            ((access(SYSTEM_BOOTANIMATION_FILE, R_OK) == 0) &&
            (mZip.open(SYSTEM_BOOTANIMATION_FILE) == NO_ERROR))) {
        mAndroidAnimation = false;
    }

    return NO_ERROR;
}

在这里为绘制做准备，包括访问到帧缓冲区设备，获取屏幕显示大小等。
判断是否为android默认开机动画。 

#define USER_BOOTANIMATION_FILE "/data/local/bootanimation.zip"
#define SYSTEM_BOOTANIMATION_FILE "/system/media/bootanimation.zip"
#define SYSTEM_ENCRYPTED_BOOTANIMATION_FILE "/system/media/bootanimation-encrypted.zip"

上面的文件只要有一个存在就代表不是android默认的 而是用户自定义的开机动画。

5.bootanimation执行动画：

准备工作做完了 就执行： 

bool BootAnimation::threadLoop()
{
    bool r;


    if (mAndroidAnimation) {
        r = android();
    } else {
        r = movie();
    }



    eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    eglDestroyContext(mDisplay, mContext);
    eglDestroySurface(mDisplay, mSurface);
    mFlingerSurface.clear();
    mFlingerSurfaceControl.clear();
    eglTerminate(mDisplay);
    IPCThreadState::self()->stopProcess();
    return r;
}

1.android默认动画：
如果是android默认的开机动画： 

bool BootAnimation::android()
{
    initTexture(&mAndroid[0], mAssets, "images/android-logo-mask.png");
    initTexture(&mAndroid[1], mAssets, "images/android-logo-shine.png");


    // clear screen
    glShadeModel(GL_FLAT);
    glDisable(GL_DITHER);
    glDisable(GL_SCISSOR_TEST);

...
}

这两张图片保存在frameworks/base/core/res/assets/images目录中.
图片android-logo-mask.png用作动画前景，它是一个镂空的“ANDROID”图像。图片android-logo-shine.png用作动画背景，它的中间包含有一个高亮的呈45度角的条纹。在每一次循环中，图片android-logo-shine.png被划分成左右两部分内容来显示。左右两个部分的图像宽度随着时间的推移而此消彼长，这样就可以使得图片android-logo-shine.png中间高亮的条纹好像在移动一样。另一方面，在每一次循环中，图片android-logo-shine.png都作为一个整体来渲染，而且它的位置是恒定不变的。由于它是一个镂空的“ANDROID”图像，因此，我们就可以通过它的镂空来看到它背后的图片android-logo-shine.png的条纹一闪一闪地划过。


2.用户自定义动画：
如果为用户自定义的开机动画： 

bool BootAnimation::movie()
{
ZipFileRO& zip(mZip);

size_t numEntries = zip.getNumEntries();
ZipEntryRO desc = zip.findEntryByName("desc.txt");
FileMap* descMap = zip.createEntryFileMap(desc);
ALOGE_IF(!descMap, "descMap is null");
if (!descMap) {
return false;
}

String8 desString((char const*)descMap->getDataPtr(),
descMap->getDataLength());
char const* s = desString.string();

Animation animation;

// Parse the description file
for (;;) {
const char* endl = strstr(s, "\n");
if (!endl) break;
String8 line(s, endl - s);
const char* l = line.string();
int fps, width, height, count, pause;
char path[256];
char pathType;

if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {

// ALOGD("> w=%d, h=%d, fps=%d", width, height, fps);
// ALOGD("jscese> w=%d, h=%d", mWidth, mHeight);


animation.width =width;
animation.height =height;
animation.fps = fps;
}
else if (sscanf(l, " %c %d %d %s", &pathType, &count, &pause, path) == 4) {
//LOGD("> type=%c, count=%d, pause=%d, path=%s", pathType, count, pause, path);
Animation::Part part;
part.playUntilComplete = pathType == 'c';
part.count = count;
part.pause = pause;
part.path = path;
animation.parts.add(part);
}

s = ++endl;
}

...
}

找到解析bootanimation.zip 压缩包，找到desc.txt 文件，这个文件描述了显示的相关的特性，包括分辨率以及显示的帧率： 

1920 1080 24  
 p   1   0   part1  
 p   0   10  part2

第一行的三个数字分别表示开机动画在屏幕中的显示宽度、高度以及帧速（fps）。剩余的每一行都用来描述一个动画片断，这些行必须要以字符“p”来开头，后面紧跟着两个数字以及一个文件目录路径名称。第一个数字表示一个片断的循环显示次数，如果它的值等于0，那么就表示无限循环地显示该动画片断。第二个数字表示每一个片断在两次循环显示之间的时间间隔。这个时间间隔是以一个帧的时间为单位的。文件目录下面保存的是一系列png文件，这些png文件会被依次显示在屏幕中。


以上面这个desct.txt文件的内容为例，它描述了一个大小为1920 x 1080的开机动画，动画的显示速度为24帧每秒。这个开机动画包含有两个片断part1和part2。片断part1只显示一次，它对应的png图片保存在目录part1中。片断part2无限循环地显示，其中，每两次循环显示的时间间隔为10 x (1 / 24)秒，它对应的png图片保存在目录part2中。


往后就是收集信息，通过帧缓冲区设备有次序的渲染这些图片了。

特别注意，android开机动画的zip包是不能压缩的！ 在ubuntu下可以使用一下命令制作bootanimation.zip： 

zip -r -0 bootanimation.zip bootanimation/ desc.txt



6.bootanimation停止：

1.activity的空闲通知：
当android开机启动到了Launcher，第一个被启动起来的应用程序的主线程空闲的时候，这个activity就会向ActivityManagerService发送一个Activity组件空闲的通知，
每当有一个新的Activity组件启动起来的时候，ActivityThread类都会向它所描述的应用程序主线程的消息队列注册一个类型为Idler的空闲消息处理器。这样一个应用程序的主线程就可以在空闲的时候，向ActivityManagerService发送一个Activity组件空闲通知，相当于是通知ActivityManagerService，一个新的Activity组件已经准备就绪了。
通过一系列的调用到/frameworks/base/services/java/com/android/server/am/ActivityManagerService.java中的： 
  public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
        final long origId = Binder.clearCallingIdentity();
        ActivityRecord r = mMainStack.activityIdleInternal(token, false, config);
...
}

调用到/frameworks/base/services/java/com/android/server/am/ActivityStack.java中的： 
final ActivityRecord activityIdleInternal(IBinder token, boolean fromTimeout,
Configuration config) {
if (localLOGV) Slog.v(TAG, "Activity idle: " + token);


ActivityRecord res = null;

...
if (mMainStack) {
if (!mService.mBooted) {
mService.mBooted = true;
enableScreen = true;
}
}
...

if (enableScreen) 
{



mService.enableScreenAfterBoot();
}
...
}


回到ActivityManagerService.java中： 
    void enableScreenAfterBoot() {
        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN,
                SystemClock.uptimeMillis());
        mWindowManager.enableScreenAfterBoot();

        synchronized (this) {
            updateEventDispatchingLocked();
        }
    }

2.WindowManagerService通信SurfaceFinger设置property：

调用到了 WindowManagerService.java中的： 
public void performEnableScreen() 
{
synchronized(mWindowMap) {
if (DEBUG_BOOT) {
RuntimeException here = new RuntimeException("here");
here.fillInStackTrace();
...
try {
   IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger");
   if (surfaceFlinger != null) {
    //Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!");
    Parcel data = Parcel.obtain();
    data.writeInterfaceToken("android.ui.ISurfaceComposer");
    surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, // BOOT_FINISHED
    data, null, 0);
    data.recycle();
    }
...
}


通过一个类型为IBinder.FIRST_CALL_TRANSACTION的进程间通信请求来通知SurfaceFlinger服务停止显示开机动画的.
 
void SurfaceFlinger::bootFinished()
{
    const nsecs_t now = systemTime();
...
 property_set("service.bootanim.exit", "1");
}

最后还是通过设置android的系统属性通知到init守护进程，init进程来处理property的改变，在这里就是停掉bootanimation这个服务进程，bootanimation动画就停止掉了。





南丶烟
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 开机动画
fengguowuhen7871的专栏
08-23 3208
1.原始的android的开机动画，貌似是android的字体然后晃动晃动。 其实这不是动画，只是两张图片。一张mask在上面，下面一张图片在不停的动。 他们在如下目录下   ./frameworks/base/core/res/assets/images/android-logo-mask.png ./frameworks/base/core/res/assets/images/andr
android开机动画
xzx_kag的专栏
12-27 533
从uboot--->linux内核-->android第一张图-->android第二张图,四个画面都是可以定制的，一般定制最后一张。 1.uboot的logo： a.替换图片且重新编译 图片位于XX/bootloader/uboot-imx/tools/logos/，图片是很多的.bmp文件，都是一些公司的logo。 其中涉及到的代码有：XX/bootloader/uboot-imx/t
FB_ROTATE_xxx宏定义
qwaszx523的博客
06-13 1348
#define FB_ROTATE_UR 0 //正常显示 #define FB_ROTATE_CW 1 //顺时针转90度 #define FB_ROTATE_UD 2 //上下倒置 #define FB_ROTATE_CCW 3 //逆时针转90度
AndroidO 图形框架下应用绘图过程——Surface创建
深入剖析Android系统
06-13 8903
Android图形框架在前几年已经分析过了，不过，随着Android版本的升级，虽然框架主体未变，但有些细节变动还是比较大的，应网友要求，今天再次以AndroidO为基础，重新介绍图形框架实现，Android图形框架包括以下三大部分：1. 应用绘图；2. SurfaceFlinger混合图层；3. Hwc Hal实现本文首先介绍AndroidO下应用的绘图过程，应用绘图也分为以下几个步骤：sp&l...
android 开机动画执行流程
最新发布
Lud的博客
06-05 1278
android开机动画原理，进程启动流程，动画播放原理。
Android系统的开机画面显示过程分析
mmdev
07-09 591
好几个月都没有更新过博客了，从今天开始，老罗将尝试对Android系统的UI实现作一个系统的分析，也算是落实之前所作出的承诺。提到Android系统的UI，我们最先接触到的便是系统在启动过程中所出现的画面了。Android系统在启动的过程中，最多可以出现三个画面，每一个画面都用来描述一个不同的启动阶段。本文将详细分析这三个开机画面的显示过程，以便可以开启我们对Android系统UI实现的分析...
Android图形-合成与显示-SurfaceTestDemo
haigand的专栏
08-11 722
通过一个最简单的测试程序直观Android系统的native层Surface的渲染显示过程。
system_media_bootanimation.zip OTT开机动画合集
07-13
5. **安卓跳动**：这可能代表的是基于Android系统的设备的开机动画，可能包含Android吉祥物——小机器人，通过跳动的形式展现系统的活力和科技感。 在Java编程语言中，虽然开机动画的制作主要涉及到Android系统的...
Android动画机制与使用技巧（四）——Android动画特效
06-03
在Android开发中，动画是提升用户体验的关键因素之一。Android提供了丰富的动画机制，让开发者能够创造出各种炫酷的视觉效果。本篇文章将深入探讨Android动画特效，主要包括补间动画（Tween Animation）和属性动画...
Android开机画面修改
12-14
除了以上提到的方法外，还可以采用其他方式修改开机动画，例如使用第三方工具： **方法二（无需重烧系统）：** 1. **下载bootanimation.zip文件：** - 下载压缩包`bootanimation.zip`，并将其放置在SD卡中。 - ...
安卓Android源码——九宫格开机密码.zip
10-12
这个"安卓Android源码——九宫格开机密码.zip"文件很可能包含了实现这一功能的源代码，让我们深入探讨一下相关的知识点。 首先，我们要了解的是Android系统的应用程序开发基础。Android是基于Linux内核的开源操作...
安卓Android源码——WelcomeLauncher.rar
10-11
- 当设备开机或重启时，Bootloader加载内核，然后内核启动Zygote进程，这是Android系统所有Java进程的父进程。 - Zygote孵化出SystemServer，SystemServer负责整个系统的生命周期管理和服务初始化。 - 在...
android surfaceflinger 代码,android surfaceflinger测试程序
weixin_34805308的博客
05-26 250
frameworks/base/libs/surfaceflinger/tests/resize/resize.cpp 是个好地方。 但是我的测试应用程序版本( 来自供应商的Eclair ) 过时了，有些 Surface API已经转移到 SurfaceControl，你必须：SurfaceComposerClient::createSurface() => SurfaceControlSu...
memset函数详解
weixin_34252090的博客
08-12 133
首先要知道memset函数是对字节为单位进行赋值的；   void *memset(void *s, int ch, size_t n);   函数解释：将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。 其实这里面的ch就是ascii为ch的字符； 将s所指向的某一块内存中的前n个 字节的内容全部设置为ch指定的ASCII值 ...
Android 开机动画路径
weixin_50212044的博客
10-24 413
安卓开机动画路径
Android开发之修改系统开机Logo与开机动画
hnjzfwy的博客
03-21 2730
Android 支持客户自定义第三方动画，我们只要将做好的动画文件，命名为bootanimation.zip 打包固件的时候存储到 /system/media 文件夹下面，Android系统就能够自动使用第三方的动画作为开机动画。
[Android 13]开机动画原理分析
qq_40731414的博客
06-15 4598
开机动画跑起来除了需要自身进程的启动外，还肯定以来显示系统的相关进程，即一定需要SurfaceFlinger的进程的合成和送显，所以这里需要启动SurfaceFlinger服务和bootanim服务，两者是在init.rc中启动。上面的构造方法中仅仅中只是获取了SF的session代理对象, 真正的加载逻辑在这个对象的第一次引用回调方法中（在前面的sp指针实例化时被回调）。的情况，这个名字也是很直白，开机动画的实现是图片逐帧动画，和电影的那种原理相同。获取对应的目标的rc文件，并将rc的内容。
Android 12 开机动画代码与流程详解
qq_43625390的博客
05-17 4624
本文整理了安卓12跟BootAnimation相关的内容，梳理了代码和绘制了流程图
Android——内存管理-lowmemorykiller 机制
热门推荐
jscese
08-07 1万+
前段时间碰到一个apk多个process依次开跑，跑到最后一个process的时候，第一个process给kill掉了，虽然第一个process中含有broadcast receive，被kill掉的原因是由于触发到了lowmemorykiller，这样一来apk最后的结果就异常了~ 尝试再三 规避掉了这个问题，记录一下~ 撰写不易,转载需注明出处：http://blog.csdn.net/jsce
android更换开机动画
08-18
要更换Android的开机动画，你可以按照以下步骤进行操作： 1. 首先，连接你的Android设备到电脑上，并确保已经启用了开发者选项和USB调试模式。 2. 打开命令行终端或命令提示符窗口，并使用以下命令将开机动画文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值