ANativeWindow是个什么东西

公司经常组织一些培训，培训的都是些奇技淫巧。什么设计模式啦，开发策略啦，git啦，repo啦，另外就是培训一些开发流程的东东，例如CMMI啦。可是，却忘记了，程序员终究要归结到三个问题上：

1.解决什么问题？

2.为什么这样解决问题？

3.有没有更好的解决方案？

这些东东才是最核心的东东。但是却是一个程序员一辈子都无法完全掌握的东西。很多人以为写出了高难度的反射代码就是很牛，也有人认为利用C++模板来进行编程就多牛多牛，还有人觉得会写makefile文件，掌握了某种高难度语言很牛。但是我认为这些都不重要，重要的是要有思想。思考者比行动者在关键时候定大局。中国人的技术书籍缺乏的就是思想。在中国，可以肯定，没有几个人能写出像thinking in java这样的鸿篇巨著，更没有人能够超越 design pattern，来描述其思想。反之，像《自己动手写操作系统》，《21天学java》，《程序员的自我修养》，《面试宝典》，《C++面试一百例》, android内核开发要点等等等等一系列的书籍在中国却是层出不穷。为什么，因为缺乏思考，来不及思考，更或者懒得思考。然而，作为一名专业级的程序员，不思考就意味着退步，不学习就意味着淘汰。

这几天一直在思考ANativeWindow是个什么东西，今天终于找到了，代码贴出来，大家参考一下。

1. struct ANativeWindow
2. {
3. #ifdef __cplusplus
4. ANativeWindow()
5. : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0)
6. {
7. common.magic = ANDROID_NATIVE_WINDOW_MAGIC;
8. common.version = sizeof(ANativeWindow);
9. memset(common.reserved, 0, sizeof(common.reserved));
10. }
11. /* Implement the methods that sp<ANativeWindow> expects so that it
12. can be used to automatically refcount ANativeWindow's. */
13. void incStrong(const void* id) const {
14. common.incRef(const_cast<android_native_base_t*>(&common));
15. }
16. void decStrong(const void* id) const {
17. common.decRef(const_cast<android_native_base_t*>(&common));
18. }
19. #endif
20. struct android_native_base_t common;
21. /* flags describing some attributes of this surface or its updater */
22. const uint32_t flags;
23. /* min swap interval supported by this updated */
24. const int   minSwapInterval;
25. /* max swap interval supported by this updated */
26. const int   maxSwapInterval;
27. /* horizontal and vertical resolution in DPI */
28. const float xdpi;
29. const float ydpi;
30. /* Some storage reserved for the OEM's driver. */
31. intptr_t    oem[4];
32. /*
33. * Set the swap interval for this surface.
34. *
35. * Returns 0 on success or -errno on error.
36. */
37. int     (*setSwapInterval)(struct ANativeWindow* window,
38. int interval);
39. /*
40. * Hook called by EGL to acquire a buffer. After this call, the buffer
41. * is not locked, so its content cannot be modified. This call may block if
42. * no buffers are available.
43. *
44. * The window holds a reference to the buffer between dequeueBuffer and
45. * either queueBuffer or cancelBuffer, so clients only need their own
46. * reference if they might use the buffer after queueing or canceling it.
47. * Holding a reference to a buffer after queueing or canceling it is only
48. * allowed if a specific buffer count has been set.
49. *
50. * Returns 0 on success or -errno on error.
51. */
52. int     (*dequeueBuffer)(struct ANativeWindow* window,
53. struct ANativeWindowBuffer** buffer);
54. /*
55. * hook called by EGL to lock a buffer. This MUST be called before modifying
56. * the content of a buffer. The buffer must have been acquired with
57. * dequeueBuffer first.
58. *
59. * Returns 0 on success or -errno on error.
60. */
61. int     (*lockBuffer)(struct ANativeWindow* window,
62. struct ANativeWindowBuffer* buffer);
63. /*
64. * Hook called by EGL when modifications to the render buffer are done.
65. * This unlocks and post the buffer.
66. *
67. * The window holds a reference to the buffer between dequeueBuffer and
68. * either queueBuffer or cancelBuffer, so clients only need their own
69. * reference if they might use the buffer after queueing or canceling it.
70. * Holding a reference to a buffer after queueing or canceling it is only
71. * allowed if a specific buffer count has been set.
72. *
73. * Buffers MUST be queued in the same order than they were dequeued.
74. *
75. * Returns 0 on success or -errno on error.
76. */
77. int     (*queueBuffer)(struct ANativeWindow* window,
78. struct ANativeWindowBuffer* buffer);
79. /*
80. * hook used to retrieve information about the native window.
81. *
82. * Returns 0 on success or -errno on error.
83. */
84. int     (*query)(const struct ANativeWindow* window,
85. int what, int* value);
86. /*
87. * hook used to perform various operations on the surface.
88. * (*perform)() is a generic mechanism to add functionality to
89. * ANativeWindow while keeping backward binary compatibility.
90. *
91. * DO NOT CALL THIS HOOK DIRECTLY.  Instead, use the helper functions
92. * defined below.
93. *
94. *  (*perform)() returns -ENOENT if the 'what' parameter is not supported
95. *  by the surface's implementation.
96. *
97. * The valid operations are:
98. *     NATIVE_WINDOW_SET_USAGE
99. *     NATIVE_WINDOW_CONNECT               (deprecated)
100. *     NATIVE_WINDOW_DISCONNECT            (deprecated)
101. *     NATIVE_WINDOW_SET_CROP
102. *     NATIVE_WINDOW_SET_BUFFER_COUNT
103. *     NATIVE_WINDOW_SET_BUFFERS_GEOMETRY  (deprecated)
104. *     NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
105. *     NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
106. *     NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
107. *     NATIVE_WINDOW_SET_BUFFERS_FORMAT
108. *     NATIVE_WINDOW_SET_SCALING_MODE
109. *     NATIVE_WINDOW_LOCK                   (private)
110. *     NATIVE_WINDOW_UNLOCK_AND_POST        (private)
111. *     NATIVE_WINDOW_API_CONNECT            (private)
112. *     NATIVE_WINDOW_API_DISCONNECT         (private)
113. *
114. */
115. int     (*perform)(struct ANativeWindow* window,
116. int operation, ... );
117. /*
118. * Hook used to cancel a buffer that has been dequeued.
119. * No synchronization is performed between dequeue() and cancel(), so
120. * either external synchronization is needed, or these functions must be
121. * called from the same thread.
122. *
123. * The window holds a reference to the buffer between dequeueBuffer and
124. * either queueBuffer or cancelBuffer, so clients only need their own
125. * reference if they might use the buffer after queueing or canceling it.
126. * Holding a reference to a buffer after queueing or canceling it is only
127. * allowed if a specific buffer count has been set.
128. */
129. int     (*cancelBuffer)(struct ANativeWindow* window,
130. struct ANativeWindowBuffer* buffer);
131. void* reserved_proc[2];
132. };