Android 中加载几百张图片做帧动画防止 OOM 的解决方案

最近，项目中有个需求：就是要做一个帧动画，按理说这个是很简单的！但是我能说这个帧动画拥有几百张图片吗？。。。。。。

填坑一 ---帧动画

一开始我的想法是直接用帧动画来做，可是我太天真了，当帧数放到 50 几张的时候，已经在有些机器上奔溃了！所以这个方案否决！

填坑二 ---GIF动图

虽然可以显示，但是已经卡的我，已经不想看了，直接放弃

填坑三 ---视频

在这里，我突然想到我可以直接把他做成一个小视频啊，而且可以极限压缩视频。最终，视频大小被压缩到 500K 左右。此时已经基本可以满足需求了，但是我们有好多类似的动画，要求在每个动画切换的时候要有衔接感，不能有突兀的感觉，所有在这里视频就不能很好的完成任务了，所有再次放弃，已经泪牛满面了！！！！

填坑四 --- SurfaceView + BitmapRegionDecoder +缓存

首先回答一下：为什么会想到这个解决方案？

  1. 首先在做帧动画的时候，大约每帧之间的时间差值是 40ms 可以说速度非常快了，在如此快速的图片切换上，自然而然的想到来了使用SurfaceView。
  2. 现在再来说说为什么想到要使用这个类 BitmapRegionDecoder .这个也是从我司游戏开发人员那儿得到的经验？他们在做游戏的时候，游戏中的切图都是放在一张大图上的，然后在根据对应的 xml,json 文件，获取相应的图片，接着再来切图。对此，我想能不能把所有的动图都放到同一张的图片上呢，之后在根据对应的描述文件，裁剪出我想要的图片呢！所以就用到了 BitmapRegionDecoder. 它的作用是：于显示图片的某一块矩形区域！之后，我在找设计人员商量一一下，把图片在尽量的压缩。之后从美工那儿获取的信息是这样的：

    json格式的描述文件：

  2. {"frames": [
  4. {
  5. 	"filename": "kidbot-正常闭眼0000",
  6. 	"frame": {"x":0,"y":0,"w":360,"h":300},
  7. 	"rotated": false,
  8. 	"trimmed": false,
  9. 	"spriteSourceSize": {"x":0,"y":0,"w":360,"h":300},
  10. 	"sourceSize": {"w":360,"h":300}
  11. }
  12. .....
  13. }

png图片：

接下来就好做了，解析 json 格式的文件，裁剪图片。

  1. 最后说一下为什么使用缓存，其实很简单，因为切换的频率实在太高了，没有必要每次都从图片中裁剪，这里就把裁剪出来的 bitmap 缓存起来在用。从而介绍内存开销！

最后给出代码：

  1. public class AnimView extends SurfaceView implements SurfaceHolder.Callback {
  2. 	private BitmapRegionDecoder bitmapRegionDecoder;
  3. 	private SurfaceHolder mHolder;
  4. 	private boolean isrunning = true;
  5. 	private AnimThread thread;
  6. 	private Paint mPaint;
  7. 	private int WIDTH = 0;
  8. 	private int HEIGHT = 0;
  9. 	private int state = -1;
  10. 	private boolean isstart = false;
  11. 	private boolean isblinkfirst = false;
  12. 	private int rate = 40;
  13. 	private int index = 0;
  14. 	private Matrix matrix;
  15. 	private Random rand;
  16. 	private Handler handler = new Handler() {
  17. 		public void handleMessage(android.os.Message msg) {
  18. 			isblinkfirst = true;
  19. 		};
  20. 	};
  21. 	private SparseArray<WeakReference<Bitmap>> weakBitmaps;
  22. 	private SparseArray<WeakReference<Bitmap>> cweakBitmaps;
  24. 	private BitmapFactory.Options options;
  26. 	public AnimView(Context context) {
  27. 		super(context);
  28. 		init();
  30. 	}
  32. 	public AnimView(Context context, AttributeSet attrs) {
  33. 		super(context, attrs);
  34. 		init();
  35. 	}
  37. 	public AnimView(Context context, AttributeSet attrs, int defStyleAttr) {
  38. 		super(context, attrs, defStyleAttr);
  39. 		init();
  40. 	}
  42. 	@SuppressLint("NewApi")
  43. 	private void init() {
  44. 		weakBitmaps = new SparseArray<WeakReference<Bitmap>>();
  45. 		cweakBitmaps = new SparseArray<WeakReference<Bitmap>>();
  46. 		mHolder = getHolder();
  47. 		mHolder.addCallback(this);
  48. 		mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
  49. 		setState(FaceBean.BLINK);
  50. 		mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
  51. 		matrix = new Matrix();
  52. 		float[] values = { -1f, 0.0f, 0.0f, 0.0f, 1f, 0.0f, 0.0f, 0.0f, 1.0f };
  53. 		matrix.setValues(values);
  54. 		WindowManager manger = (WindowManager) getContext().getSystemService(
  55. 				Context.WINDOW_SERVICE);
  56. 		DisplayMetrics displayMetrics = new DisplayMetrics();
  57. 		manger.getDefaultDisplay().getMetrics(displayMetrics);
  58. 		WIDTH = displayMetrics.widthPixels / 2;
  59. 		HEIGHT = displayMetrics.heightPixels / 2;
  60. 		rand = new Random();
  61. 		options = new Options();
  62. 		options.inPreferredConfig = Bitmap.Config.RGB_565;
  64. 	}
  66. 	@Override
  67. 	public void surfaceCreated(SurfaceHolder holder) {
  68. 		handler.sendEmptyMessageDelayed(0, 1000 * (4 + rand.nextInt(4)));
  69. 		thread = new AnimThread();
  70. 		thread.start();
  71. 	}
  73. 	@Override
  74. 	public void surfaceChanged(SurfaceHolder holder, int format, int width,
  75. 			int height) {
  77. 	}
  79. 	@Override
  80. 	public void surfaceDestroyed(SurfaceHolder holder) {
  81. 		if (thread != null) {
  82. 			thread.stopThread();
  83. 		}
  84. 	}
  86. 	public class AnimThread extends Thread {
  88. 		@Override
  89. 		public void run() {
  90. 			super.run();
  91. 			SurfaceHolder holder = mHolder;
  92. 			while (isrunning) {
  93. 				Canvas canvas = holder.lockCanvas();
  94. 				if (canvas == null)
  95. 					continue;
  96. 				synchronized (AnimThread.class) {
  97. 					AnimBean.Frames frames;
  98. 					switch (state) {
  99. 					case FaceBean.BLINK:
  100. 						frames = KidbotRobotApplication.animBlink.getFrames()
  101. 								.get(index);
  102. 						if (frames.getFrame().getW() <= 0) {
  103. 						} else {
  104. 							Rect rect = new Rect(frames.getFrame().getX(),
  105. 									frames.getFrame().getY(), frames.getFrame()
  106. 											.getX()
  107. 											+ frames.getSourceSize().getW(),
  108. 									frames.getFrame().getY()
  109. 											+ frames.getSourceSize().getH());
  110. 							WeakReference<Bitmap> weakBitmap = weakBitmaps
  111. 									.get(index);
  112. 							Bitmap map = null;
  113. 							if (weakBitmap == null) {
  114. 								map = bitmapRegionDecoder.decodeRegion(rect,
  115. 										options);
  116. 								weakBitmaps.put(index,
  117. 										new WeakReference<Bitmap>(map));
  118. 							} else {
  119. 								map=weakBitmap.get();
  120. 								if (map == null) {
  121. 									map = bitmapRegionDecoder.decodeRegion(
  122. 											rect, options);
  123. 									weakBitmaps.put(index,
  124. 											new WeakReference<Bitmap>(map));
  125. 								}
  126. 							}
  127. 							if (map == null) {
  128. 								holder.unlockCanvasAndPost(canvas);
  129. 								continue;
  130. 							}
  131. 							mPaint.setXfermode(new PorterDuffXfermode(
  132. 									Mode.CLEAR));
  133. 							canvas.drawPaint(mPaint);
  134. 							mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
  135. 							canvas.drawBitmap(map,
  136. 									(int) (WIDTH - (map.getWidth() * 1) - 150),
  137. 									(int) (HEIGHT - (map.getHeight() / 2)),
  138. 									mPaint);
  139. 							canvas.drawBitmap(map, (int) (WIDTH + 150),
  140. 									(int) (HEIGHT - (map.getHeight() / 2)),
  141. 									mPaint);
  143. 							if (index == 0) {
  145. 							}
  147. 							if (map.isRecycled()) {
  148. 								map.recycle();
  149. 							}
  151. 						}
  152. 						if (!isstart) {
  153. 							if (index < KidbotRobotApplication.animBlink
  154. 									.getFrames().size()) {
  155. 								index++;
  156. 								if (index == KidbotRobotApplication.animBlink
  157. 										.getFrames().size()) {
  158. 									index--;
  159. 									isstart = true;
  160. 									if (rand.nextInt(10) <= 2) {
  161. 										index = 1;
  162. 									}
  163. 								}
  164. 							} else {
  165. 								index--;
  166. 								isstart = true;
  167. 							}
  168. 						} else {
  169. 							if (index > 0) {
  170. 								index--;
  171. 								if (index == 0) {
  172. 									isstart = false;
  173. 								}
  174. 							} else {
  175. 								index++;
  176. 								isstart = false;
  177. 							}
  178. 						}
  179. 						if (!isblinkfirst) {
  180. 							index = 0;
  181. 						} else {
  182. 							if (index == KidbotRobotApplication.animBlink
  183. 									.getFrames().size() - 1) {
  184. 								isblinkfirst = false;
  185. 								index = 0;
  186. 								handler.sendEmptyMessageDelayed(0,
  187. 										1000 * (4 + rand.nextInt(4)));
  188. 							}
  189. 						}
  190. 						break;
  191. 					case FaceBean.ANGRY:
  192. 						frames = KidbotRobotApplication.animAngry.getFrames()
  193. 								.get(index);
  194. 						if (frames.getFrame().getW() <= 0) {
  195. 						} else {
  196. 							Rect rect = new Rect(frames.getFrame().getX(),
  197. 									frames.getFrame().getY(), frames.getFrame()
  198. 											.getX() + frames.getFrame().getW(),
  199. 									frames.getFrame().getH()
  200. 											+ frames.getFrame().getX());
  201. 							WeakReference<Bitmap> weakBitmap = weakBitmaps
  202. 									.get(index);
  203. 							Bitmap map = null;
  204. 							if (weakBitmap == null) {
  205. 								map = bitmapRegionDecoder.decodeRegion(rect,
  206. 										options);
  207. 								weakBitmaps.put(index,
  208. 										new WeakReference<Bitmap>(map));
  209. 							} else {
  210. 								map=weakBitmap.get();
  211. 								if (map == null) {
  212. 									map = bitmapRegionDecoder.decodeRegion(
  213. 											rect, options);
  214. 									weakBitmaps.put(index,
  215. 											new WeakReference<Bitmap>(map));
  216. 								}
  217. 							}
  218. 							if (map == null) {
  219. 								holder.unlockCanvasAndPost(canvas);
  220. 								continue;
  221. 							}
  222. 							mPaint.setXfermode(new PorterDuffXfermode(
  223. 									Mode.CLEAR));
  224. 							canvas.drawPaint(mPaint);
  225. 							mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
  226. 							Bitmap dstbmp =null;
  227. 							weakBitmap=cweakBitmaps.get(index);
  228. 							if(weakBitmap==null){
  229. 								dstbmp = Bitmap.createBitmap(map, 0, 0,
  230. 										map.getWidth(), map.getHeight(),
  231. 										matrix, true);
  232. 								cweakBitmaps.put(index,
  233. 										new WeakReference<Bitmap>(dstbmp));
  234. 							}else{
  235. 								dstbmp=weakBitmap.get();
  236. 								if(dstbmp==null){
  237. 									dstbmp = Bitmap.createBitmap(map, 0, 0,
  238. 											map.getWidth(), map.getHeight(),
  239. 											matrix, true);
  240. 									cweakBitmaps.put(index,
  241. 											new WeakReference<Bitmap>(dstbmp));
  242. 								}
  243. 							}
  244. 							canvas.drawBitmap(
  245. 									map,
  246. 									frames.getSpriteSourceSize().getX()
  247. 											+ (int) (WIDTH
  248. 													- (map.getWidth() * 1) - 150),
  249. 									frames.getSpriteSourceSize().getY()
  250. 											+ (int) (HEIGHT - (map.getHeight() / 2)),
  251. 									mPaint);
  252. 							canvas.drawBitmap(dstbmp, frames
  253. 									.getSpriteSourceSize().getX()
  254. 									+ (int) (WIDTH + 150), frames
  255. 									.getSpriteSourceSize().getY()
  256. 									+ (int) (HEIGHT - (map.getHeight() / 2)),
  257. 									mPaint);
  258. 							if (dstbmp.isRecycled()) {
  259. 								dstbmp.recycle();
  260. 							}
  261. 							if (map.isRecycled()) {
  262. 								map.recycle();
  263. 							}
  264. 						}
  265. 						if (!isstart) {
  266. 							if (index < KidbotRobotApplication.animAngry
  267. 									.getFrames().size()) {
  268. 								index++;
  269. 								if (index == KidbotRobotApplication.animAngry
  270. 										.getFrames().size()) {
  271. 									index--;
  272. 									isstart = true;
  273. 								}
  274. 							} else {
  275. 								index--;
  276. 								isstart = true;
  277. 							}
  278. 						} else {
  279. 							if (index > 0) {
  280. 								index--;
  281. 								if (index == 0) {
  282. 									isstart = false;
  283. 								}
  284. 							} else {
  285. 								index++;
  286. 								isstart = false;
  287. 							}
  288. 						}
  289. 						break;
  290. 					case FaceBean.HAPPY:
  291. 						frames = KidbotRobotApplication.animHappy.getFrames()
  292. 								.get(index);
  293. 						if (frames.getFrame().getW() <= 0) {
  294. 						} else {
  295. 							Rect rect = new Rect(frames.getFrame().getX(),
  296. 									frames.getFrame().getY(), frames.getFrame()
  297. 											.getX()
  298. 											+ frames.getSourceSize().getW(),
  299. 									frames.getFrame().getY()
  300. 											+ frames.getSourceSize().getH());
  301. 							WeakReference<Bitmap> weakBitmap = weakBitmaps
  302. 									.get(index);
  303. 							Bitmap map = null;
  304. 							if (weakBitmap == null) {
  305. 								map = bitmapRegionDecoder.decodeRegion(rect,
  306. 										options);
  307. 								weakBitmaps.put(index,
  308. 										new WeakReference<Bitmap>(map));
  309. 							} else {
  310. 								map=weakBitmap.get();
  311. 								if (map == null) {
  312. 									map = bitmapRegionDecoder.decodeRegion(
  313. 											rect, options);
  314. 									weakBitmaps.put(index,
  315. 											new WeakReference<Bitmap>(map));
  316. 								}
  317. 							}
  318. 							if (map == null) {
  319. 								holder.unlockCanvasAndPost(canvas);
  320. 								continue;
  321. 							}
  322. 							mPaint.setXfermode(new PorterDuffXfermode(
  323. 									Mode.CLEAR));
  324. 							canvas.drawPaint(mPaint);
  325. 							mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
  326. 							Bitmap dstbmp =null;
  327. 							weakBitmap=cweakBitmaps.get(index);
  328. 							if(weakBitmap==null){
  329. 								dstbmp = Bitmap.createBitmap(map, 0, 0,
  330. 										map.getWidth(), map.getHeight(),
  331. 										matrix, true);
  332. 								cweakBitmaps.put(index,
  333. 										new WeakReference<Bitmap>(dstbmp));
  334. 							}else{
  335. 								dstbmp=weakBitmap.get();
  336. 								if(dstbmp==null){
  337. 									dstbmp = Bitmap.createBitmap(map, 0, 0,
  338. 											map.getWidth(), map.getHeight(),
  339. 											matrix, true);
  340. 									cweakBitmaps.put(index,
  341. 											new WeakReference<Bitmap>(dstbmp));
  342. 								}
  343. 							}
  344. 							canvas.drawBitmap(
  345. 									map,
  346. 									frames.getSpriteSourceSize().getX()
  347. 											+ (int) (WIDTH
  348. 													- (map.getWidth() * 1) - 150),
  349. 									frames.getSpriteSourceSize().getY()
  350. 											+ (int) (HEIGHT - (map.getHeight() / 2)),
  351. 									mPaint);
  352. 							canvas.drawBitmap(dstbmp, frames
  353. 									.getSpriteSourceSize().getX()
  354. 									+ (int) (WIDTH + 150), frames
  355. 									.getSpriteSourceSize().getY()
  356. 									+ (int) (HEIGHT - (map.getHeight() / 2)),
  357. 									mPaint);
  358. 							// if (dstbmp.isRecycled()) {
  359. 							// dstbmp.recycle();
  360. 							// }
  361. 							// if (map.isRecycled()) {
  362. 							// map.recycle();
  363. 							// }
  365. 						}
  366. 						if (!isstart) {
  367. 							if (index < KidbotRobotApplication.animHappy
  368. 									.getFrames().size()) {
  369. 								index++;
  370. 								if (index == KidbotRobotApplication.animHappy
  371. 										.getFrames().size()) {
  372. 									index--;
  373. 									isstart = true;
  374. 								}
  375. 							} else {
  376. 								index--;
  377. 								isstart = true;
  378. 							}
  379. 						} else {
  380. 							if (index > 0) {
  381. 								index--;
  382. 								if (index == 0) {
  383. 									isstart = false;
  384. 								}
  385. 							} else {
  386. 								index++;
  387. 								isstart = false;
  388. 							}
  389. 						}
  390. 						break;
  391. 					case FaceBean.RESOLVE:
  392. 						break;
  393. 					case FaceBean.RISUS:
  394. 						break;
  395. 					case FaceBean.SEERIGHT:
  396. 						break;
  397. 					case FaceBean.SAD:
  398. 						frames = KidbotRobotApplication.animSad.getFrames()
  399. 								.get(index);
  400. 						if (frames.getFrame().getW() <= 0) {
  401. 						} else {
  402. 							Rect rect = new Rect(frames.getFrame().getX(),
  403. 									frames.getFrame().getY(), frames.getFrame()
  404. 											.getX()
  405. 											+ frames.getSourceSize().getW(),
  406. 									frames.getFrame().getY()
  407. 											+ frames.getSourceSize().getH());
  409. 							WeakReference<Bitmap> weakBitmap = weakBitmaps
  410. 									.get(index);
  411. 							Bitmap map = null;
  412. 							if (weakBitmap == null) {
  413. 								map = bitmapRegionDecoder.decodeRegion(rect,
  414. 										options);
  415. 								weakBitmaps.put(index,
  416. 										new WeakReference<Bitmap>(map));
  417. 							} else {
  418. 								map=weakBitmap.get();
  419. 								if (map == null) {
  420. 									map = bitmapRegionDecoder.decodeRegion(
  421. 											rect, options);
  422. 									weakBitmaps.put(index,
  423. 											new WeakReference<Bitmap>(map));
  424. 								}
  425. 							}
  426. 							if (map == null) {
  427. 								holder.unlockCanvasAndPost(canvas);
  428. 								continue;
  429. 							}
  430. 							mPaint.setXfermode(new PorterDuffXfermode(
  431. 									Mode.CLEAR));
  432. 							canvas.drawPaint(mPaint);
  433. 							mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
  434. 							Bitmap dstbmp =null;
  435. 							weakBitmap=cweakBitmaps.get(index);
  436. 							if(weakBitmap==null){
  437. 								dstbmp = Bitmap.createBitmap(map, 0, 0,
  438. 										map.getWidth(), map.getHeight(),
  439. 										matrix, true);
  440. 								cweakBitmaps.put(index,
  441. 										new WeakReference<Bitmap>(dstbmp));
  442. 							}else{
  443. 								dstbmp=weakBitmap.get();
  444. 								if(dstbmp==null){
  445. 									dstbmp = Bitmap.createBitmap(map, 0, 0,
  446. 											map.getWidth(), map.getHeight(),
  447. 											matrix, true);
  448. 									cweakBitmaps.put(index,
  449. 											new WeakReference<Bitmap>(dstbmp));
  450. 								}
  451. 							}
  452. 							canvas.drawBitmap(
  453. 									map,
  454. 									frames.getSpriteSourceSize().getX()
  455. 											+ (int) (WIDTH
  456. 													- (map.getWidth() * 1) - 150),
  457. 									frames.getSpriteSourceSize().getY()
  458. 											+ (int) (HEIGHT - (map.getHeight() / 2)),
  459. 									mPaint);
  460. 							canvas.drawBitmap(dstbmp, frames
  461. 									.getSpriteSourceSize().getX()
  462. 									+ (int) (WIDTH + 150), frames
  463. 									.getSpriteSourceSize().getY()
  464. 									+ (int) (HEIGHT - (map.getHeight() / 2)),
  465. 									mPaint);
  466. 							if (dstbmp.isRecycled()) {
  467. 								dstbmp.recycle();
  468. 							}
  469. 							if (map.isRecycled()) {
  470. 								map.recycle();
  471. 							}
  472. 						}
  473. 						if (!isstart) {
  474. 							if (index < KidbotRobotApplication.animSad
  475. 									.getFrames().size()) {
  476. 								index++;
  477. 								if (index == KidbotRobotApplication.animSad
  478. 										.getFrames().size()) {
  479. 									index--;
  480. 									isstart = true;
  481. 								}
  482. 							} else {
  483. 								index--;
  484. 								isstart = true;
  485. 							}
  486. 						} else {
  487. 							if (index > 0) {
  488. 								index--;
  489. 								if (index == 0) {
  490. 									isstart = false;
  491. 								}
  492. 							} else {
  493. 								index++;
  494. 								isstart = false;
  495. 							}
  496. 						}
  497. 						break;
  498. 					default:
  499. 						break;
  500. 					}
  501. 				}
  502. 				holder.unlockCanvasAndPost(canvas);
  503. 				try {
  504. 					Thread.sleep(rate);
  505. 				} catch (InterruptedException e) {
  506. 					e.printStackTrace();
  507. 				}
  508. 			}
  509. 		}
  511. 		public void stopThread() {
  512. 			isrunning = false;
  513. 			try {
  514. 				join();
  515. 			} catch (InterruptedException e) {
  516. 				e.printStackTrace();
  517. 			}
  518. 		}
  519. 	}
  521. 	public synchronized void setRate(int rate) {
  522. 		this.rate = rate;
  523. 	}
  525. 	public int getState() {
  526. 		return this.state;
  527. 	}
  529. 	public synchronized void setState(int state) {
  530. 		// if (FaceBean.BLINK == this.state) {
  531. 		// while ((index != KidbotRobotApplication.animBlink.getFrames()
  532. 		// .size() - 1)) {
  533. 		// continue;
  534. 		// }
  535. 		// }
  536. 		cweakBitmaps.clear();
  537. 		weakBitmaps.clear();
  538. 		this.state = state;
  539. 		this.index = 0;
  541. 		switch (state) {
  542. 		case FaceBean.BLINK:
  543. 			try {
  544. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  545. 						getContext().getAssets().open("kidbot_blink.png"),
  546. 						false);
  547. 			} catch (IOException e) {
  548. 				e.printStackTrace();
  549. 			}
  550. 			break;
  551. 		case FaceBean.ANGRY:
  552. 			try {
  553. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  554. 						getContext().getAssets().open("kidbot_angry.png"),
  555. 						false);
  556. 			} catch (IOException e) {
  557. 				e.printStackTrace();
  558. 			}
  559. 			break;
  560. 		case FaceBean.HAPPY:
  561. 			try {
  562. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  563. 						getContext().getAssets().open("kidbot_happy.png"),
  564. 						false);
  565. 			} catch (IOException e) {
  566. 				e.printStackTrace();
  567. 			}
  568. 			break;
  569. 		case FaceBean.RESOLVE:
  570. 			try {
  571. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  572. 						getContext().getAssets().open("kidbot_blink.png"),
  573. 						false);
  574. 			} catch (IOException e) {
  575. 				e.printStackTrace();
  576. 			}
  577. 			break;
  578. 		case FaceBean.RISUS:
  579. 			try {
  580. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  581. 						getContext().getAssets().open("kidbot_blink.png"),
  582. 						false);
  583. 			} catch (IOException e) {
  584. 				e.printStackTrace();
  585. 			}
  586. 			break;
  587. 		case FaceBean.SEERIGHT:
  588. 			break;
  589. 		case FaceBean.SAD:
  590. 			try {
  591. 				bitmapRegionDecoder = BitmapRegionDecoder.newInstance(
  592. 						getContext().getAssets().open("kidbot_sad.png"), false);
  593. 			} catch (IOException e) {
  594. 				e.printStackTrace();
  595. 			}
  596. 			break;
  597. 		}
  598. 	}
  600. 	public synchronized void setRunning(boolean isrunning) {
  601. 		this.isrunning = isrunning;
  602. 	}
  604. 	public synchronized void addIndex() {
  605. 		this.index++;
  606. 	}
  608. }

Android 中加载几百张图片做帧动画防止 OOM 的解决方案的更多相关文章

  1. Android中加载位图的方法

    Android中加载位图的关键的代码: AssetManager assets =context.getAssets(); //用一个AssetManager 对象来从应用程序包的已编译资源中为工程加 ...

  2. Android中加载事件的方式

    Android中加载事件的方式 通过内部类的方式实现 通过外部类的方式实现 通过属性的方式实现 通过自身实现接口的方式实现 通过内部类的方式实现 Demo btn_Login.setOnClickLi ...

  3. android中加载的html获取的宽高不正确

    wap页面使用 js库是zepto,按照惯例在$(function(){})中,来获取当前可视区的宽高,但得到的宽高却与预想的相差十万八千里. 原本android手机的浏览器设定的宽高基本是360*6 ...

  4. Android 中加载本地Html 跨域问题,http协议允许加载

    一.需求: 后台加载HTML的包时间太长,太卡,让把所有的HTML包放到前台:使用的是file://协议,有些内容和样式加载不出来,H5那边说需要用http://协议来加载: 二.处理过程: 安卓最简 ...

  5. Android高效加载大图、多图解决方案，有效避免程序内存溢出现象

    好久没有写博客了,今天就先写一个小的关于在Android中加载大图如何避免内存溢出的问题. 后面会写如何使用缓存技术的核心类,android.support.v4.util.LruCache来加载图片 ...

  6. Android图片加载框架Picasso最全使用教程1

    Picasso介绍 Picasso是Square公司开源的一个Android图形缓存库 A powerful image downloading and caching library for And ...

  7. Android图片加载库：最全面的Picasso讲解

    前言 上文已经对当今 Android主流的图片加载库 进行了全面介绍 & 对比 如果你还没阅读,我建议你先移步这里阅读 今天我们来学习其中一个Android主流的图片加载库的使用 - Pica ...

  8. Android动态加载so文件

    在Android中调用动态库文件(*.so)都是通过jni的方式,而且往往在apk或jar包中调用so文件时,都要将对应so文件打包进apk或jar包,工程目录下图: 以上方式的存在的问题: 1.缺少 ...

  9. Android应用开发提高系列（4）——Android动态加载（上）——加载未安装APK中的类

    前言 近期做换肤功能,由于换肤程度较高,受限于平台本身,实现起来较复杂,暂时搁置了该功能,但也积累了一些经验,将分两篇文章来写这部分的内容,欢迎交流! 关键字:Android动态加载 声明 欢迎转载, ...

随机推荐

  1. TocControl控件图层无法显示问题

    在窗口里的层层嵌套SplitContainer后,出现最内层SplitContainer内部TocControl控件图层无法显示问题:加载完mxd后代后加上axTOCControl1.SetBuddy ...

  2. msado.tli

    // Created by Microsoft (R) C/C++ Compiler Version 10.00.40219.01 (d0b01b1b).//// e:\threadpool\mysq ...

  3. 从pdf 文件中抽取特定的页面

    前段时间买了一个kindle 电子书阅读器.我想用它来读的pdf文档.当然最主要是用来读python标准库&mysql的官方文档. 问题就来了.这两个都是大头书.之前用mac看还好.用kind ...

  4. JVM虚拟机（五）：JDK8内存模型—消失的PermGen

    一.JVM 内存模型 根据 JVM 规范,JVM 内存共分为虚拟机栈.堆.方法区.程序计数器.本地方法栈五个部分. 1.虚拟机栈: 每个线程有一个私有的栈,随着线程的创建而创建.栈里面存着的是一种叫“ ...

  5. 【Android】14.1 内部文件存储和读取

    分类:C#.Android.VS2015: 创建日期:2016-02-27 一.简介 内部存储(Internal storage)是指将应用程序建立的私有文件保存在内部存储器(移动经销商卖的那种容量较 ...

  6. echarts报表

    <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding= ...

  7. [基础]sizeof和strlen

    转自网络 首先切记,sizeof不能用来求字符串长度 1.sizeof操作符的结果类型是size_t,它在头文件中typedef为unsigned int类型.该类型保证能容纳实现所建立的最大对象的字 ...

  8. 用c++封装linux系统调用

    #include <pthread.h> #include <cstdlib> #include <ctime> #include <iostream> ...

  9. linux进程同步机制_转

    转自:Linux进程同步机制 具体应用可参考:线程同步       IPC之信号量 为了能够有效的控制多个进程之间的沟通过程,保证沟通过程的有序和和谐,OS必须提供一 定的同步机制保证进程之间不会自说 ...

  10. 深入分析DDR（转载）

    深入分析:我们为何需要DDR2内存技术 http://www.cnblogs.com/thx-bj/archive/2008/04/02/1134040.html 文/IT168评测室特约 Myddn ...