1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_NDEBUG 0
18 #define LOG_TAG "BootAnimation"
19
20 #include <stdint.h>
21 #include <sys/inotify.h>
22 #include <sys/poll.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <math.h>
26 #include <fcntl.h>
27 #include <utils/misc.h>
28 #include <signal.h>
29 #include <time.h>
30
31 #include <cutils/properties.h>
32
33 #include <androidfw/AssetManager.h>
34 #include <binder/IPCThreadState.h>
35 #include <utils/Atomic.h>
36 #include <utils/Errors.h>
37 #include <utils/Log.h>
38
39 #include <ui/PixelFormat.h>
40 #include <ui/Rect.h>
41 #include <ui/Region.h>
42 #include <ui/DisplayInfo.h>
43
44 #include <gui/ISurfaceComposer.h>
45 #include <gui/Surface.h>
46 #include <gui/SurfaceComposerClient.h>
47
48 // TODO: Fix Skia.
49 #pragma GCC diagnostic push
50 #pragma GCC diagnostic ignored "-Wunused-parameter"
51 #include <SkBitmap.h>
52 #include <SkStream.h>
53 #include <SkImageDecoder.h>
54 #pragma GCC diagnostic pop
55
56 #include <GLES/gl.h>
57 #include <GLES/glext.h>
58 #include <EGL/eglext.h>
59
60 #include "BootAnimation.h"
61 #include "audioplay.h"
62
63 namespace android {
64
65 static const char OEM_BOOTANIMATION_FILE[] = "/oem/media/bootanimation.zip";
66 static const char SYSTEM_BOOTANIMATION_FILE[] = "/system/media/bootanimation.zip";
67 static const char SYSTEM_ENCRYPTED_BOOTANIMATION_FILE[] = "/system/media/bootanimation-encrypted.zip";
68 static const char SYSTEM_DATA_DIR_PATH[] = "/data/system";
69 static const char SYSTEM_TIME_DIR_NAME[] = "time";
70 static const char SYSTEM_TIME_DIR_PATH[] = "/data/system/time";
71 static const char LAST_TIME_CHANGED_FILE_NAME[] = "last_time_change";
72 static const char LAST_TIME_CHANGED_FILE_PATH[] = "/data/system/time/last_time_change";
73 static const char ACCURATE_TIME_FLAG_FILE_NAME[] = "time_is_accurate";
74 static const char ACCURATE_TIME_FLAG_FILE_PATH[] = "/data/system/time/time_is_accurate";
75 // Java timestamp format. Don't show the clock if the date is before 2000-01-01 00:00:00.
76 static const long long ACCURATE_TIME_EPOCH = 946684800000;
77 static const char EXIT_PROP_NAME[] = "service.bootanim.exit";
78 static const char PLAY_SOUND_PROP_NAME[] = "persist.sys.bootanim.play_sound";
79 static const int ANIM_ENTRY_NAME_MAX = 256;
80 static const char BOOT_COMPLETED_PROP_NAME[] = "sys.boot_completed";
81 static const char BOOTREASON_PROP_NAME[] = "ro.boot.bootreason";
82 // bootreasons list in "system/core/bootstat/bootstat.cpp".
83 static const std::vector<std::string> PLAY_SOUND_BOOTREASON_BLACKLIST {
84 "kernel_panic",
85 "Panic",
86 "Watchdog",
87 };
88
89 // ---------------------------------------------------------------------------
90
BootAnimation()91 BootAnimation::BootAnimation() : Thread(false), mClockEnabled(true), mTimeIsAccurate(false),
92 mTimeCheckThread(NULL) {
93 mSession = new SurfaceComposerClient();
94
95 // If the system has already booted, the animation is not being used for a boot.
96 mSystemBoot = !property_get_bool(BOOT_COMPLETED_PROP_NAME, 0);
97 }
98
~BootAnimation()99 BootAnimation::~BootAnimation() {}
100
onFirstRef()101 void BootAnimation::onFirstRef() {
102 status_t err = mSession->linkToComposerDeath(this);
103 ALOGE_IF(err, "linkToComposerDeath failed (%s) ", strerror(-err));
104 if (err == NO_ERROR) {
105 run("BootAnimation", PRIORITY_DISPLAY);
106 }
107 }
108
session() const109 sp<SurfaceComposerClient> BootAnimation::session() const {
110 return mSession;
111 }
112
113
binderDied(const wp<IBinder> &)114 void BootAnimation::binderDied(const wp<IBinder>&)
115 {
116 // woah, surfaceflinger died!
117 ALOGD("SurfaceFlinger died, exiting...");
118
119 // calling requestExit() is not enough here because the Surface code
120 // might be blocked on a condition variable that will never be updated.
121 kill( getpid(), SIGKILL );
122 requestExit();
123 audioplay::destroy();
124 }
125
initTexture(Texture * texture,AssetManager & assets,const char * name)126 status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
127 const char* name) {
128 Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
129 if (asset == NULL)
130 return NO_INIT;
131 SkBitmap bitmap;
132 SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
133 &bitmap, kUnknown_SkColorType, SkImageDecoder::kDecodePixels_Mode);
134 asset->close();
135 delete asset;
136
137 // ensure we can call getPixels(). No need to call unlock, since the
138 // bitmap will go out of scope when we return from this method.
139 bitmap.lockPixels();
140
141 const int w = bitmap.width();
142 const int h = bitmap.height();
143 const void* p = bitmap.getPixels();
144
145 GLint crop[4] = { 0, h, w, -h };
146 texture->w = w;
147 texture->h = h;
148
149 glGenTextures(1, &texture->name);
150 glBindTexture(GL_TEXTURE_2D, texture->name);
151
152 switch (bitmap.colorType()) {
153 case kAlpha_8_SkColorType:
154 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
155 GL_UNSIGNED_BYTE, p);
156 break;
157 case kARGB_4444_SkColorType:
158 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
159 GL_UNSIGNED_SHORT_4_4_4_4, p);
160 break;
161 case kN32_SkColorType:
162 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
163 GL_UNSIGNED_BYTE, p);
164 break;
165 case kRGB_565_SkColorType:
166 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
167 GL_UNSIGNED_SHORT_5_6_5, p);
168 break;
169 default:
170 break;
171 }
172
173 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
174 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
175 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
176 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
177 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
178 return NO_ERROR;
179 }
180
initTexture(const Animation::Frame & frame)181 status_t BootAnimation::initTexture(const Animation::Frame& frame)
182 {
183 //StopWatch watch("blah");
184
185 SkBitmap bitmap;
186 SkMemoryStream stream(frame.map->getDataPtr(), frame.map->getDataLength());
187 SkImageDecoder* codec = SkImageDecoder::Factory(&stream);
188 if (codec != NULL) {
189 codec->setDitherImage(false);
190 codec->decode(&stream, &bitmap,
191 kN32_SkColorType,
192 SkImageDecoder::kDecodePixels_Mode);
193 delete codec;
194 }
195
196 // FileMap memory is never released until application exit.
197 // Release it now as the texture is already loaded and the memory used for
198 // the packed resource can be released.
199 delete frame.map;
200
201 // ensure we can call getPixels(). No need to call unlock, since the
202 // bitmap will go out of scope when we return from this method.
203 bitmap.lockPixels();
204
205 const int w = bitmap.width();
206 const int h = bitmap.height();
207 const void* p = bitmap.getPixels();
208
209 GLint crop[4] = { 0, h, w, -h };
210 int tw = 1 << (31 - __builtin_clz(w));
211 int th = 1 << (31 - __builtin_clz(h));
212 if (tw < w) tw <<= 1;
213 if (th < h) th <<= 1;
214
215 switch (bitmap.colorType()) {
216 case kN32_SkColorType:
217 if (!mUseNpotTextures && (tw != w || th != h)) {
218 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tw, th, 0, GL_RGBA,
219 GL_UNSIGNED_BYTE, 0);
220 glTexSubImage2D(GL_TEXTURE_2D, 0,
221 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, p);
222 } else {
223 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
224 GL_UNSIGNED_BYTE, p);
225 }
226 break;
227
228 case kRGB_565_SkColorType:
229 if (!mUseNpotTextures && (tw != w || th != h)) {
230 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tw, th, 0, GL_RGB,
231 GL_UNSIGNED_SHORT_5_6_5, 0);
232 glTexSubImage2D(GL_TEXTURE_2D, 0,
233 0, 0, w, h, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, p);
234 } else {
235 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
236 GL_UNSIGNED_SHORT_5_6_5, p);
237 }
238 break;
239 default:
240 break;
241 }
242
243 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
244
245 return NO_ERROR;
246 }
247
readyToRun()248 status_t BootAnimation::readyToRun() {
249 mAssets.addDefaultAssets();
250
251 sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
252 ISurfaceComposer::eDisplayIdMain));
253 DisplayInfo dinfo;
254 status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &dinfo);
255 if (status)
256 return -1;
257
258 // create the native surface
259 sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"),
260 dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
261
262 SurfaceComposerClient::openGlobalTransaction();
263 control->setLayer(0x40000000);
264 SurfaceComposerClient::closeGlobalTransaction();
265
266 sp<Surface> s = control->getSurface();
267
268 // initialize opengl and egl
269 const EGLint attribs[] = {
270 EGL_RED_SIZE, 8,
271 EGL_GREEN_SIZE, 8,
272 EGL_BLUE_SIZE, 8,
273 EGL_DEPTH_SIZE, 0,
274 EGL_NONE
275 };
276 EGLint w, h;
277 EGLint numConfigs;
278 EGLConfig config;
279 EGLSurface surface;
280 EGLContext context;
281
282 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
283
284 eglInitialize(display, 0, 0);
285 eglChooseConfig(display, attribs, &config, 1, &numConfigs);
286 surface = eglCreateWindowSurface(display, config, s.get(), NULL);
287 context = eglCreateContext(display, config, NULL, NULL);
288 eglQuerySurface(display, surface, EGL_WIDTH, &w);
289 eglQuerySurface(display, surface, EGL_HEIGHT, &h);
290
291 if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
292 return NO_INIT;
293
294 mDisplay = display;
295 mContext = context;
296 mSurface = surface;
297 mWidth = w;
298 mHeight = h;
299 mFlingerSurfaceControl = control;
300 mFlingerSurface = s;
301
302 // If the device has encryption turned on or is in process
303 // of being encrypted we show the encrypted boot animation.
304 char decrypt[PROPERTY_VALUE_MAX];
305 property_get("vold.decrypt", decrypt, "");
306
307 bool encryptedAnimation = atoi(decrypt) != 0 || !strcmp("trigger_restart_min_framework", decrypt);
308
309 if (encryptedAnimation && (access(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE, R_OK) == 0)) {
310 mZipFileName = SYSTEM_ENCRYPTED_BOOTANIMATION_FILE;
311 }
312 else if (access(OEM_BOOTANIMATION_FILE, R_OK) == 0) {
313 mZipFileName = OEM_BOOTANIMATION_FILE;
314 }
315 else if (access(SYSTEM_BOOTANIMATION_FILE, R_OK) == 0) {
316 mZipFileName = SYSTEM_BOOTANIMATION_FILE;
317 }
318 return NO_ERROR;
319 }
320
threadLoop()321 bool BootAnimation::threadLoop()
322 {
323 bool r;
324 // We have no bootanimation file, so we use the stock android logo
325 // animation.
326 if (mZipFileName.isEmpty()) {
327 r = android();
328 } else {
329 r = movie();
330 }
331
332 eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
333 eglDestroyContext(mDisplay, mContext);
334 eglDestroySurface(mDisplay, mSurface);
335 mFlingerSurface.clear();
336 mFlingerSurfaceControl.clear();
337 eglTerminate(mDisplay);
338 IPCThreadState::self()->stopProcess();
339 return r;
340 }
341
android()342 bool BootAnimation::android()
343 {
344 initTexture(&mAndroid[0], mAssets, "images/android-logo-mask.png");
345 initTexture(&mAndroid[1], mAssets, "images/android-logo-shine.png");
346
347 // clear screen
348 glShadeModel(GL_FLAT);
349 glDisable(GL_DITHER);
350 glDisable(GL_SCISSOR_TEST);
351 glClearColor(0,0,0,1);
352 glClear(GL_COLOR_BUFFER_BIT);
353 eglSwapBuffers(mDisplay, mSurface);
354
355 glEnable(GL_TEXTURE_2D);
356 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
357
358 const GLint xc = (mWidth - mAndroid[0].w) / 2;
359 const GLint yc = (mHeight - mAndroid[0].h) / 2;
360 const Rect updateRect(xc, yc, xc + mAndroid[0].w, yc + mAndroid[0].h);
361
362 glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
363 updateRect.height());
364
365 // Blend state
366 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
367 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
368
369 const nsecs_t startTime = systemTime();
370 do {
371 nsecs_t now = systemTime();
372 double time = now - startTime;
373 float t = 4.0f * float(time / us2ns(16667)) / mAndroid[1].w;
374 GLint offset = (1 - (t - floorf(t))) * mAndroid[1].w;
375 GLint x = xc - offset;
376
377 glDisable(GL_SCISSOR_TEST);
378 glClear(GL_COLOR_BUFFER_BIT);
379
380 glEnable(GL_SCISSOR_TEST);
381 glDisable(GL_BLEND);
382 glBindTexture(GL_TEXTURE_2D, mAndroid[1].name);
383 glDrawTexiOES(x, yc, 0, mAndroid[1].w, mAndroid[1].h);
384 glDrawTexiOES(x + mAndroid[1].w, yc, 0, mAndroid[1].w, mAndroid[1].h);
385
386 glEnable(GL_BLEND);
387 glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);
388 glDrawTexiOES(xc, yc, 0, mAndroid[0].w, mAndroid[0].h);
389
390 EGLBoolean res = eglSwapBuffers(mDisplay, mSurface);
391 if (res == EGL_FALSE)
392 break;
393
394 // 12fps: don't animate too fast to preserve CPU
395 const nsecs_t sleepTime = 83333 - ns2us(systemTime() - now);
396 if (sleepTime > 0)
397 usleep(sleepTime);
398
399 checkExit();
400 } while (!exitPending());
401
402 glDeleteTextures(1, &mAndroid[0].name);
403 glDeleteTextures(1, &mAndroid[1].name);
404 return false;
405 }
406
407
checkExit()408 void BootAnimation::checkExit() {
409 // Allow surface flinger to gracefully request shutdown
410 char value[PROPERTY_VALUE_MAX];
411 property_get(EXIT_PROP_NAME, value, "0");
412 int exitnow = atoi(value);
413 if (exitnow) {
414 requestExit();
415 }
416 }
417
418 // Parse a color represented as an HTML-style 'RRGGBB' string: each pair of
419 // characters in str is a hex number in [0, 255], which are converted to
420 // floating point values in the range [0.0, 1.0] and placed in the
421 // corresponding elements of color.
422 //
423 // If the input string isn't valid, parseColor returns false and color is
424 // left unchanged.
parseColor(const char str[7],float color[3])425 static bool parseColor(const char str[7], float color[3]) {
426 float tmpColor[3];
427 for (int i = 0; i < 3; i++) {
428 int val = 0;
429 for (int j = 0; j < 2; j++) {
430 val *= 16;
431 char c = str[2*i + j];
432 if (c >= '0' && c <= '9') val += c - '0';
433 else if (c >= 'A' && c <= 'F') val += (c - 'A') + 10;
434 else if (c >= 'a' && c <= 'f') val += (c - 'a') + 10;
435 else return false;
436 }
437 tmpColor[i] = static_cast<float>(val) / 255.0f;
438 }
439 memcpy(color, tmpColor, sizeof(tmpColor));
440 return true;
441 }
442
443
readFile(ZipFileRO * zip,const char * name,String8 & outString)444 static bool readFile(ZipFileRO* zip, const char* name, String8& outString)
445 {
446 ZipEntryRO entry = zip->findEntryByName(name);
447 ALOGE_IF(!entry, "couldn't find %s", name);
448 if (!entry) {
449 return false;
450 }
451
452 FileMap* entryMap = zip->createEntryFileMap(entry);
453 zip->releaseEntry(entry);
454 ALOGE_IF(!entryMap, "entryMap is null");
455 if (!entryMap) {
456 return false;
457 }
458
459 outString.setTo((char const*)entryMap->getDataPtr(), entryMap->getDataLength());
460 delete entryMap;
461 return true;
462 }
463
464 // The time glyphs are stored in a single image of height 64 pixels. Each digit is 40 pixels wide,
465 // and the colon character is half that at 20 pixels. The glyph order is '0123456789:'.
466 // We render 24 hour time.
drawTime(const Texture & clockTex,const int yPos)467 void BootAnimation::drawTime(const Texture& clockTex, const int yPos) {
468 static constexpr char TIME_FORMAT[] = "%H:%M";
469 static constexpr int TIME_LENGTH = sizeof(TIME_FORMAT);
470
471 static constexpr int DIGIT_HEIGHT = 64;
472 static constexpr int DIGIT_WIDTH = 40;
473 static constexpr int COLON_WIDTH = DIGIT_WIDTH / 2;
474 static constexpr int TIME_WIDTH = (DIGIT_WIDTH * 4) + COLON_WIDTH;
475
476 if (clockTex.h < DIGIT_HEIGHT || clockTex.w < (10 * DIGIT_WIDTH + COLON_WIDTH)) {
477 ALOGE("Clock texture is too small; abandoning boot animation clock");
478 mClockEnabled = false;
479 return;
480 }
481
482 time_t rawtime;
483 time(&rawtime);
484 struct tm* timeInfo = localtime(&rawtime);
485
486 char timeBuff[TIME_LENGTH];
487 size_t length = strftime(timeBuff, TIME_LENGTH, TIME_FORMAT, timeInfo);
488
489 if (length != TIME_LENGTH - 1) {
490 ALOGE("Couldn't format time; abandoning boot animation clock");
491 mClockEnabled = false;
492 return;
493 }
494
495 glEnable(GL_BLEND); // Allow us to draw on top of the animation
496 glBindTexture(GL_TEXTURE_2D, clockTex.name);
497
498 int xPos = (mWidth - TIME_WIDTH) / 2;
499 int cropRect[4] = { 0, DIGIT_HEIGHT, DIGIT_WIDTH, -DIGIT_HEIGHT };
500
501 for (int i = 0; i < TIME_LENGTH - 1; i++) {
502 char c = timeBuff[i];
503 int width = DIGIT_WIDTH;
504 int pos = c - '0'; // Position in the character list
505 if (pos < 0 || pos > 10) {
506 continue;
507 }
508 if (c == ':') {
509 width = COLON_WIDTH;
510 }
511
512 // Crop the texture to only the pixels in the current glyph
513 int left = pos * DIGIT_WIDTH;
514 cropRect[0] = left;
515 cropRect[2] = width;
516 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect);
517
518 glDrawTexiOES(xPos, yPos, 0, width, DIGIT_HEIGHT);
519
520 xPos += width;
521 }
522
523 glDisable(GL_BLEND); // Return to the animation's default behaviour
524 glBindTexture(GL_TEXTURE_2D, 0);
525 }
526
parseAnimationDesc(Animation & animation)527 bool BootAnimation::parseAnimationDesc(Animation& animation)
528 {
529 String8 desString;
530
531 if (!readFile(animation.zip, "desc.txt", desString)) {
532 return false;
533 }
534 char const* s = desString.string();
535
536 // Parse the description file
537 for (;;) {
538 const char* endl = strstr(s, "\n");
539 if (endl == NULL) break;
540 String8 line(s, endl - s);
541 const char* l = line.string();
542 int fps = 0;
543 int width = 0;
544 int height = 0;
545 int count = 0;
546 int pause = 0;
547 int clockPosY = -1;
548 char path[ANIM_ENTRY_NAME_MAX];
549 char color[7] = "000000"; // default to black if unspecified
550
551 char pathType;
552 if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {
553 // ALOGD("> w=%d, h=%d, fps=%d", width, height, fps);
554 animation.width = width;
555 animation.height = height;
556 animation.fps = fps;
557 } else if (sscanf(l, " %c %d %d %s #%6s %d",
558 &pathType, &count, &pause, path, color, &clockPosY) >= 4) {
559 // ALOGD("> type=%c, count=%d, pause=%d, path=%s, color=%s, clockPosY=%d", pathType, count, pause, path, color, clockPosY);
560 Animation::Part part;
561 part.playUntilComplete = pathType == 'c';
562 part.count = count;
563 part.pause = pause;
564 part.path = path;
565 part.clockPosY = clockPosY;
566 part.audioData = NULL;
567 part.animation = NULL;
568 if (!parseColor(color, part.backgroundColor)) {
569 ALOGE("> invalid color '#%s'", color);
570 part.backgroundColor[0] = 0.0f;
571 part.backgroundColor[1] = 0.0f;
572 part.backgroundColor[2] = 0.0f;
573 }
574 animation.parts.add(part);
575 }
576 else if (strcmp(l, "$SYSTEM") == 0) {
577 // ALOGD("> SYSTEM");
578 Animation::Part part;
579 part.playUntilComplete = false;
580 part.count = 1;
581 part.pause = 0;
582 part.audioData = NULL;
583 part.animation = loadAnimation(String8(SYSTEM_BOOTANIMATION_FILE));
584 if (part.animation != NULL)
585 animation.parts.add(part);
586 }
587 s = ++endl;
588 }
589
590 return true;
591 }
592
preloadZip(Animation & animation)593 bool BootAnimation::preloadZip(Animation& animation)
594 {
595 // read all the data structures
596 const size_t pcount = animation.parts.size();
597 void *cookie = NULL;
598 ZipFileRO* zip = animation.zip;
599 if (!zip->startIteration(&cookie)) {
600 return false;
601 }
602
603 Animation::Part* partWithAudio = NULL;
604 ZipEntryRO entry;
605 char name[ANIM_ENTRY_NAME_MAX];
606 while ((entry = zip->nextEntry(cookie)) != NULL) {
607 const int foundEntryName = zip->getEntryFileName(entry, name, ANIM_ENTRY_NAME_MAX);
608 if (foundEntryName > ANIM_ENTRY_NAME_MAX || foundEntryName == -1) {
609 ALOGE("Error fetching entry file name");
610 continue;
611 }
612
613 const String8 entryName(name);
614 const String8 path(entryName.getPathDir());
615 const String8 leaf(entryName.getPathLeaf());
616 if (leaf.size() > 0) {
617 for (size_t j = 0; j < pcount; j++) {
618 if (path == animation.parts[j].path) {
619 uint16_t method;
620 // supports only stored png files
621 if (zip->getEntryInfo(entry, &method, NULL, NULL, NULL, NULL, NULL)) {
622 if (method == ZipFileRO::kCompressStored) {
623 FileMap* map = zip->createEntryFileMap(entry);
624 if (map) {
625 Animation::Part& part(animation.parts.editItemAt(j));
626 if (leaf == "audio.wav") {
627 // a part may have at most one audio file
628 part.audioData = (uint8_t *)map->getDataPtr();
629 part.audioLength = map->getDataLength();
630 partWithAudio = ∂
631 } else if (leaf == "trim.txt") {
632 part.trimData.setTo((char const*)map->getDataPtr(),
633 map->getDataLength());
634 } else {
635 Animation::Frame frame;
636 frame.name = leaf;
637 frame.map = map;
638 frame.trimWidth = animation.width;
639 frame.trimHeight = animation.height;
640 frame.trimX = 0;
641 frame.trimY = 0;
642 part.frames.add(frame);
643 }
644 }
645 } else {
646 ALOGE("bootanimation.zip is compressed; must be only stored");
647 }
648 }
649 }
650 }
651 }
652 }
653
654 // If there is trimData present, override the positioning defaults.
655 for (Animation::Part& part : animation.parts) {
656 const char* trimDataStr = part.trimData.string();
657 for (size_t frameIdx = 0; frameIdx < part.frames.size(); frameIdx++) {
658 const char* endl = strstr(trimDataStr, "\n");
659 // No more trimData for this part.
660 if (endl == NULL) {
661 break;
662 }
663 String8 line(trimDataStr, endl - trimDataStr);
664 const char* lineStr = line.string();
665 trimDataStr = ++endl;
666 int width = 0, height = 0, x = 0, y = 0;
667 if (sscanf(lineStr, "%dx%d+%d+%d", &width, &height, &x, &y) == 4) {
668 Animation::Frame& frame(part.frames.editItemAt(frameIdx));
669 frame.trimWidth = width;
670 frame.trimHeight = height;
671 frame.trimX = x;
672 frame.trimY = y;
673 } else {
674 ALOGE("Error parsing trim.txt, line: %s", lineStr);
675 break;
676 }
677 }
678 }
679
680 // Create and initialize audioplay if there is a wav file in any of the animations.
681 if (partWithAudio != NULL) {
682 ALOGD("found audio.wav, creating playback engine");
683 if (!audioplay::create(partWithAudio->audioData, partWithAudio->audioLength)) {
684 return false;
685 }
686 }
687
688 zip->endIteration(cookie);
689
690 return true;
691 }
692
movie()693 bool BootAnimation::movie()
694 {
695 Animation* animation = loadAnimation(mZipFileName);
696 if (animation == NULL)
697 return false;
698
699 bool anyPartHasClock = false;
700 for (size_t i=0; i < animation->parts.size(); i++) {
701 if(animation->parts[i].clockPosY >= 0) {
702 anyPartHasClock = true;
703 break;
704 }
705 }
706 if (!anyPartHasClock) {
707 mClockEnabled = false;
708 }
709
710 // Check if npot textures are supported
711 mUseNpotTextures = false;
712 String8 gl_extensions;
713 const char* exts = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
714 if (!exts) {
715 glGetError();
716 } else {
717 gl_extensions.setTo(exts);
718 if ((gl_extensions.find("GL_ARB_texture_non_power_of_two") != -1) ||
719 (gl_extensions.find("GL_OES_texture_npot") != -1)) {
720 mUseNpotTextures = true;
721 }
722 }
723
724 // Blend required to draw time on top of animation frames.
725 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
726 glShadeModel(GL_FLAT);
727 glDisable(GL_DITHER);
728 glDisable(GL_SCISSOR_TEST);
729 glDisable(GL_BLEND);
730
731 glBindTexture(GL_TEXTURE_2D, 0);
732 glEnable(GL_TEXTURE_2D);
733 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
734 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
735 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
736 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
737 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
738
739 bool clockTextureInitialized = false;
740 if (mClockEnabled) {
741 clockTextureInitialized = (initTexture(&mClock, mAssets, "images/clock64.png") == NO_ERROR);
742 mClockEnabled = clockTextureInitialized;
743 }
744
745 if (mClockEnabled && !updateIsTimeAccurate()) {
746 mTimeCheckThread = new TimeCheckThread(this);
747 mTimeCheckThread->run("BootAnimation::TimeCheckThread", PRIORITY_NORMAL);
748 }
749
750 playAnimation(*animation);
751
752 if (mTimeCheckThread != NULL) {
753 mTimeCheckThread->requestExit();
754 mTimeCheckThread = NULL;
755 }
756
757 releaseAnimation(animation);
758
759 if (clockTextureInitialized) {
760 glDeleteTextures(1, &mClock.name);
761 }
762
763 return false;
764 }
765
playAnimation(const Animation & animation)766 bool BootAnimation::playAnimation(const Animation& animation)
767 {
768 const size_t pcount = animation.parts.size();
769 nsecs_t frameDuration = s2ns(1) / animation.fps;
770 const int animationX = (mWidth - animation.width) / 2;
771 const int animationY = (mHeight - animation.height) / 2;
772
773 for (size_t i=0 ; i<pcount ; i++) {
774 const Animation::Part& part(animation.parts[i]);
775 const size_t fcount = part.frames.size();
776 glBindTexture(GL_TEXTURE_2D, 0);
777
778 // Handle animation package
779 if (part.animation != NULL) {
780 playAnimation(*part.animation);
781 if (exitPending())
782 break;
783 continue; //to next part
784 }
785
786 for (int r=0 ; !part.count || r<part.count ; r++) {
787 // Exit any non playuntil complete parts immediately
788 if(exitPending() && !part.playUntilComplete)
789 break;
790
791 // only play audio file the first time we animate the part
792 if (r == 0 && part.audioData && playSoundsAllowed()) {
793 ALOGD("playing clip for part%d, size=%d", (int) i, part.audioLength);
794 audioplay::playClip(part.audioData, part.audioLength);
795 }
796
797 glClearColor(
798 part.backgroundColor[0],
799 part.backgroundColor[1],
800 part.backgroundColor[2],
801 1.0f);
802
803 for (size_t j=0 ; j<fcount && (!exitPending() || part.playUntilComplete) ; j++) {
804 const Animation::Frame& frame(part.frames[j]);
805 nsecs_t lastFrame = systemTime();
806
807 if (r > 0) {
808 glBindTexture(GL_TEXTURE_2D, frame.tid);
809 } else {
810 if (part.count != 1) {
811 glGenTextures(1, &frame.tid);
812 glBindTexture(GL_TEXTURE_2D, frame.tid);
813 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
814 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
815 }
816 initTexture(frame);
817 }
818
819 const int xc = animationX + frame.trimX;
820 const int yc = animationY + frame.trimY;
821 Region clearReg(Rect(mWidth, mHeight));
822 clearReg.subtractSelf(Rect(xc, yc, xc+frame.trimWidth, yc+frame.trimHeight));
823 if (!clearReg.isEmpty()) {
824 Region::const_iterator head(clearReg.begin());
825 Region::const_iterator tail(clearReg.end());
826 glEnable(GL_SCISSOR_TEST);
827 while (head != tail) {
828 const Rect& r2(*head++);
829 glScissor(r2.left, mHeight - r2.bottom, r2.width(), r2.height());
830 glClear(GL_COLOR_BUFFER_BIT);
831 }
832 glDisable(GL_SCISSOR_TEST);
833 }
834 // specify the y center as ceiling((mHeight - frame.trimHeight) / 2)
835 // which is equivalent to mHeight - (yc + frame.trimHeight)
836 glDrawTexiOES(xc, mHeight - (yc + frame.trimHeight),
837 0, frame.trimWidth, frame.trimHeight);
838 if (mClockEnabled && mTimeIsAccurate && part.clockPosY >= 0) {
839 drawTime(mClock, part.clockPosY);
840 }
841
842 eglSwapBuffers(mDisplay, mSurface);
843
844 nsecs_t now = systemTime();
845 nsecs_t delay = frameDuration - (now - lastFrame);
846 //ALOGD("%lld, %lld", ns2ms(now - lastFrame), ns2ms(delay));
847 lastFrame = now;
848
849 if (delay > 0) {
850 struct timespec spec;
851 spec.tv_sec = (now + delay) / 1000000000;
852 spec.tv_nsec = (now + delay) % 1000000000;
853 int err;
854 do {
855 err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
856 } while (err<0 && errno == EINTR);
857 }
858
859 checkExit();
860 }
861
862 usleep(part.pause * ns2us(frameDuration));
863
864 // For infinite parts, we've now played them at least once, so perhaps exit
865 if(exitPending() && !part.count)
866 break;
867 }
868
869 }
870
871 // Free textures created for looping parts now that the animation is done.
872 for (const Animation::Part& part : animation.parts) {
873 if (part.count != 1) {
874 const size_t fcount = part.frames.size();
875 for (size_t j = 0; j < fcount; j++) {
876 const Animation::Frame& frame(part.frames[j]);
877 glDeleteTextures(1, &frame.tid);
878 }
879 }
880 }
881
882 // we've finally played everything we're going to play
883 audioplay::setPlaying(false);
884 audioplay::destroy();
885
886 return true;
887 }
888
releaseAnimation(Animation * animation) const889 void BootAnimation::releaseAnimation(Animation* animation) const
890 {
891 for (Vector<Animation::Part>::iterator it = animation->parts.begin(),
892 e = animation->parts.end(); it != e; ++it) {
893 if (it->animation)
894 releaseAnimation(it->animation);
895 }
896 if (animation->zip)
897 delete animation->zip;
898 delete animation;
899 }
900
loadAnimation(const String8 & fn)901 BootAnimation::Animation* BootAnimation::loadAnimation(const String8& fn)
902 {
903 if (mLoadedFiles.indexOf(fn) >= 0) {
904 ALOGE("File \"%s\" is already loaded. Cyclic ref is not allowed",
905 fn.string());
906 return NULL;
907 }
908 ZipFileRO *zip = ZipFileRO::open(fn);
909 if (zip == NULL) {
910 ALOGE("Failed to open animation zip \"%s\": %s",
911 fn.string(), strerror(errno));
912 return NULL;
913 }
914
915 Animation *animation = new Animation;
916 animation->fileName = fn;
917 animation->zip = zip;
918 mLoadedFiles.add(animation->fileName);
919
920 parseAnimationDesc(*animation);
921 if (!preloadZip(*animation)) {
922 return NULL;
923 }
924
925
926 mLoadedFiles.remove(fn);
927 return animation;
928 }
929
playSoundsAllowed() const930 bool BootAnimation::playSoundsAllowed() const {
931 // Only play sounds for system boots, not runtime restarts.
932 if (!mSystemBoot) {
933 return false;
934 }
935
936 // Read the system property to see if we should play the sound.
937 // If it's not present, default to allowed.
938 if (!property_get_bool(PLAY_SOUND_PROP_NAME, 1)) {
939 return false;
940 }
941
942 // Don't play sounds if this is a reboot due to an error.
943 char bootreason[PROPERTY_VALUE_MAX];
944 if (property_get(BOOTREASON_PROP_NAME, bootreason, nullptr) > 0) {
945 for (const auto& str : PLAY_SOUND_BOOTREASON_BLACKLIST) {
946 if (strcasecmp(str.c_str(), bootreason) == 0) {
947 return false;
948 }
949 }
950 }
951 return true;
952 }
953
updateIsTimeAccurate()954 bool BootAnimation::updateIsTimeAccurate() {
955 static constexpr long long MAX_TIME_IN_PAST = 60000LL * 60LL * 24LL * 30LL; // 30 days
956 static constexpr long long MAX_TIME_IN_FUTURE = 60000LL * 90LL; // 90 minutes
957
958 if (mTimeIsAccurate) {
959 return true;
960 }
961
962 struct stat statResult;
963 if(stat(ACCURATE_TIME_FLAG_FILE_PATH, &statResult) == 0) {
964 mTimeIsAccurate = true;
965 return true;
966 }
967
968 FILE* file = fopen(LAST_TIME_CHANGED_FILE_PATH, "r");
969 if (file != NULL) {
970 long long lastChangedTime = 0;
971 fscanf(file, "%lld", &lastChangedTime);
972 fclose(file);
973 if (lastChangedTime > 0) {
974 struct timespec now;
975 clock_gettime(CLOCK_REALTIME, &now);
976 // Match the Java timestamp format
977 long long rtcNow = (now.tv_sec * 1000LL) + (now.tv_nsec / 1000000LL);
978 if (ACCURATE_TIME_EPOCH < rtcNow
979 && lastChangedTime > (rtcNow - MAX_TIME_IN_PAST)
980 && lastChangedTime < (rtcNow + MAX_TIME_IN_FUTURE)) {
981 mTimeIsAccurate = true;
982 }
983 }
984 }
985
986 return mTimeIsAccurate;
987 }
988
TimeCheckThread(BootAnimation * bootAnimation)989 BootAnimation::TimeCheckThread::TimeCheckThread(BootAnimation* bootAnimation) : Thread(false),
990 mInotifyFd(-1), mSystemWd(-1), mTimeWd(-1), mBootAnimation(bootAnimation) {}
991
~TimeCheckThread()992 BootAnimation::TimeCheckThread::~TimeCheckThread() {
993 // mInotifyFd may be -1 but that's ok since we're not at risk of attempting to close a valid FD.
994 close(mInotifyFd);
995 }
996
threadLoop()997 bool BootAnimation::TimeCheckThread::threadLoop() {
998 bool shouldLoop = doThreadLoop() && !mBootAnimation->mTimeIsAccurate
999 && mBootAnimation->mClockEnabled;
1000 if (!shouldLoop) {
1001 close(mInotifyFd);
1002 mInotifyFd = -1;
1003 }
1004 return shouldLoop;
1005 }
1006
doThreadLoop()1007 bool BootAnimation::TimeCheckThread::doThreadLoop() {
1008 static constexpr int BUFF_LEN (10 * (sizeof(struct inotify_event) + NAME_MAX + 1));
1009
1010 // Poll instead of doing a blocking read so the Thread can exit if requested.
1011 struct pollfd pfd = { mInotifyFd, POLLIN, 0 };
1012 ssize_t pollResult = poll(&pfd, 1, 1000);
1013
1014 if (pollResult == 0) {
1015 return true;
1016 } else if (pollResult < 0) {
1017 ALOGE("Could not poll inotify events");
1018 return false;
1019 }
1020
1021 char buff[BUFF_LEN] __attribute__ ((aligned(__alignof__(struct inotify_event))));;
1022 ssize_t length = read(mInotifyFd, buff, BUFF_LEN);
1023 if (length == 0) {
1024 return true;
1025 } else if (length < 0) {
1026 ALOGE("Could not read inotify events");
1027 return false;
1028 }
1029
1030 const struct inotify_event *event;
1031 for (char* ptr = buff; ptr < buff + length; ptr += sizeof(struct inotify_event) + event->len) {
1032 event = (const struct inotify_event *) ptr;
1033 if (event->wd == mSystemWd && strcmp(SYSTEM_TIME_DIR_NAME, event->name) == 0) {
1034 addTimeDirWatch();
1035 } else if (event->wd == mTimeWd && (strcmp(LAST_TIME_CHANGED_FILE_NAME, event->name) == 0
1036 || strcmp(ACCURATE_TIME_FLAG_FILE_NAME, event->name) == 0)) {
1037 return !mBootAnimation->updateIsTimeAccurate();
1038 }
1039 }
1040
1041 return true;
1042 }
1043
addTimeDirWatch()1044 void BootAnimation::TimeCheckThread::addTimeDirWatch() {
1045 mTimeWd = inotify_add_watch(mInotifyFd, SYSTEM_TIME_DIR_PATH,
1046 IN_CLOSE_WRITE | IN_MOVED_TO | IN_ATTRIB);
1047 if (mTimeWd > 0) {
1048 // No need to watch for the time directory to be created if it already exists
1049 inotify_rm_watch(mInotifyFd, mSystemWd);
1050 mSystemWd = -1;
1051 }
1052 }
1053
readyToRun()1054 status_t BootAnimation::TimeCheckThread::readyToRun() {
1055 mInotifyFd = inotify_init();
1056 if (mInotifyFd < 0) {
1057 ALOGE("Could not initialize inotify fd");
1058 return NO_INIT;
1059 }
1060
1061 mSystemWd = inotify_add_watch(mInotifyFd, SYSTEM_DATA_DIR_PATH, IN_CREATE | IN_ATTRIB);
1062 if (mSystemWd < 0) {
1063 close(mInotifyFd);
1064 mInotifyFd = -1;
1065 ALOGE("Could not add watch for %s", SYSTEM_DATA_DIR_PATH);
1066 return NO_INIT;
1067 }
1068
1069 addTimeDirWatch();
1070
1071 if (mBootAnimation->updateIsTimeAccurate()) {
1072 close(mInotifyFd);
1073 mInotifyFd = -1;
1074 return ALREADY_EXISTS;
1075 }
1076
1077 return NO_ERROR;
1078 }
1079
1080 // ---------------------------------------------------------------------------
1081
1082 }
1083 ; // namespace android
1084
