几个月之前，接触Android recovery源代码的时候，看ScreenRecoveryUI类的时候，那时候C++基础还不是特别好，一直不明白以下的初始化方式：
下面这个是Recovery的一个构造函数，代码位于：screen_ui.cpp，它的类的实现在screen_ui.h。
如下这个ScreenRecoveryUI类，这个类是继承于RecoveryUI类的：
这个文件在screen_ui.h
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
class ScreenRecoveryUI : public RecoveryUI { public: ScreenRecoveryUI(); void Init(); void SetLocale(const char* locale); // overall recovery state ("background image") void SetBackground(Icon icon); // progress indicator void SetProgressType(ProgressType type); void ShowProgress(float portion, float seconds); void SetProgress(float fraction); void SetStage(int current, int max); // text log void ShowText(bool visible); bool IsTextVisible(); bool WasTextEverVisible(); // printing messages void Print(const char* fmt, ...) __printflike(2, 3); void ShowFile(const char* filename); // menu display void StartMenu(const char* const * headers, const char* const * items, int initial_selection); int SelectMenu(int sel); void EndMenu(); void KeyLongPress(int); void Redraw(); enum UIElement { HEADER, MENU, MENU_SEL_BG, MENU_SEL_BG_ACTIVE, MENU_SEL_FG, LOG, TEXT_FILL, INFO }; void SetColor(UIElement e); private: Icon currentIcon; int installingFrame; const char* locale; bool rtl_locale; pthread_mutex_t updateMutex; GRSurface* backgroundIcon[5]; GRSurface* backgroundText[5]; GRSurface** installation; GRSurface* progressBarEmpty; GRSurface* progressBarFill; GRSurface* stageMarkerEmpty; GRSurface* stageMarkerFill; ProgressType progressBarType; float progressScopeStart, progressScopeSize, progress; double progressScopeTime, progressScopeDuration; // true when both graphics pages are the same (except for the progress bar). bool pagesIdentical; size_t text_cols_, text_rows_; // Log text overlay, displayed when a magic key is pressed. char** text_; size_t text_col_, text_row_, text_top_; bool show_text; bool show_text_ever; // has show_text ever been true? char** menu_; const char* const* menu_headers_; bool show_menu; int menu_items, menu_sel; // An alternate text screen, swapped with 'text_' when we're viewing a log file. char** file_viewer_text_; pthread_t progress_thread_; int animation_fps; int installing_frames; int iconX, iconY; int stage, max_stage; void draw_background_locked(Icon icon); void draw_progress_locked(); void draw_screen_locked(); void update_screen_locked(); void update_progress_locked(); static void* ProgressThreadStartRoutine(void* data); void ProgressThreadLoop(); void ShowFile(FILE*); void PutChar(char); void ClearText(); void DrawHorizontalRule(int* y); void DrawTextLine(int* y, const char* line, bool bold); void DrawTextLines(int* y, const char* const* lines); void LoadBitmap(const char* filename, GRSurface** surface); void LoadBitmapArray(const char* filename, int* frames, GRSurface*** surface); void LoadLocalizedBitmap(const char* filename, GRSurface** surface);}; |
下面是这个类的构造函数的实现，其中构造函数就采用了初始化列表的方式来初始化字段，以下构造函数的实现在screen_ui.cpp文件中可以找到。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
ScreenRecoveryUI::ScreenRecoveryUI() : currentIcon(NONE), installingFrame(0), locale(nullptr), rtl_locale(false), progressBarType(EMPTY), progressScopeStart(0), progressScopeSize(0), progress(0), pagesIdentical(false), text_cols_(0), text_rows_(0), text_(nullptr), text_col_(0), text_row_(0), text_top_(0), show_text(false), show_text_ever(false), menu_(nullptr), show_menu(false), menu_items(0), menu_sel(0), file_viewer_text_(nullptr), animation_fps(20), installing_frames(-1), stage(-1), max_stage(-1) { for (int i = 0; i < 5; i++) { backgroundIcon[i] = nullptr; } pthread_mutex_init(&updateMutex, nullptr);} |
可以来看看RecoveryUI类:
在ui.h中：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
class RecoveryUI { public: RecoveryUI(); virtual ~RecoveryUI() { } // Initialize the object; called before anything else. virtual void Init(); // Show a stage indicator. Call immediately after Init(). virtual void SetStage(int current, int max) = 0; // After calling Init(), you can tell the UI what locale it is operating in. virtual void SetLocale(const char* locale) = 0; // Set the overall recovery state ("background image"). enum Icon { NONE, INSTALLING_UPDATE, ERASING, NO_COMMAND, ERROR }; virtual void SetBackground(Icon icon) = 0; // --- progress indicator --- enum ProgressType { EMPTY, INDETERMINATE, DETERMINATE }; virtual void SetProgressType(ProgressType determinate) = 0; // Show a progress bar and define the scope of the next operation: // portion - fraction of the progress bar the next operation will use // seconds - expected time interval (progress bar moves at this minimum rate) virtual void ShowProgress(float portion, float seconds) = 0; // Set progress bar position (0.0 - 1.0 within the scope defined // by the last call to ShowProgress). virtual void SetProgress(float fraction) = 0; // --- text log --- virtual void ShowText(bool visible) = 0; virtual bool IsTextVisible() = 0; virtual bool WasTextEverVisible() = 0; // Write a message to the on-screen log (shown if the user has // toggled on the text display). virtual void Print(const char* fmt, ...) __printflike(2, 3) = 0; virtual void ShowFile(const char* filename) = 0; // --- key handling --- // Wait for a key and return it. May return -1 after timeout. virtual int WaitKey(); virtual bool IsKeyPressed(int key); virtual bool IsLongPress(); // Returns true if you have the volume up/down and power trio typical // of phones and tablets, false otherwise. virtual bool HasThreeButtons(); // Erase any queued-up keys. virtual void FlushKeys(); // Called on each key press, even while operations are in progress. // Return value indicates whether an immediate operation should be // triggered (toggling the display, rebooting the device), or if // the key should be enqueued for use by the main thread. enum KeyAction { ENQUEUE, TOGGLE, REBOOT, IGNORE }; virtual KeyAction CheckKey(int key, bool is_long_press); // Called when a key is held down long enough to have been a // long-press (but before the key is released). This means that // if the key is eventually registered (released without any other // keys being pressed in the meantime), CheckKey will be called with // 'is_long_press' true. virtual void KeyLongPress(int key); // Normally in recovery there's a key sequence that triggers // immediate reboot of the device, regardless of what recovery is // doing (with the default CheckKey implementation, it's pressing // the power button 7 times in row). Call this to enable or // disable that feature. It is enabled by default. virtual void SetEnableReboot(bool enabled); // --- menu display --- // Display some header text followed by a menu of items, which appears // at the top of the screen (in place of any scrolling ui_print() // output, if necessary). virtual void StartMenu(const char* const * headers, const char* const * items, int initial_selection) = 0; // Set the menu highlight to the given index, wrapping if necessary. // Returns the actual item selected. virtual int SelectMenu(int sel) = 0; // End menu mode, resetting the text overlay so that ui_print() // statements will be displayed. virtual void EndMenu() = 0;protected: void EnqueueKey(int key_code);private: // Key event input queue pthread_mutex_t key_queue_mutex; pthread_cond_t key_queue_cond; int key_queue[256], key_queue_len; char key_pressed[KEY_MAX + 1]; // under key_queue_mutex int key_last_down; // under key_queue_mutex bool key_long_press; // under key_queue_mutex int key_down_count; // under key_queue_mutex bool enable_reboot; // under key_queue_mutex int rel_sum; int consecutive_power_keys; int last_key; bool has_power_key; bool has_up_key; bool has_down_key; struct key_timer_t { RecoveryUI* ui; int key_code; int count; }; pthread_t input_thread_; void OnKeyDetected(int key_code); static int InputCallback(int fd, uint32_t epevents, void* data); int OnInputEvent(int fd, uint32_t epevents); void ProcessKey(int key_code, int updown); bool IsUsbConnected(); static void* time_key_helper(void* cookie); void time_key(int key_code, int count);};ui.cpp中，也是采用字段初始化的方式来实现构造函数：RecoveryUI::RecoveryUI() : key_queue_len(0), key_last_down(-1), key_long_press(false), key_down_count(0), enable_reboot(true), consecutive_power_keys(0), last_key(-1), has_power_key(false), has_up_key(false), has_down_key(false) { pthread_mutex_init(&key_queue_mutex, nullptr); pthread_cond_init(&key_queue_cond, nullptr); memset(key_pressed, 0, sizeof(key_pressed));} |
现在看明白了。
写一个测试案例看看就懂了，果然一例解千愁啊！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
#include <iostream>using namespace std ;class ScreenRecoveryUI { private : int r , g , b ; char buffer[10] ; char *p ; public : ScreenRecoveryUI(); void setvalue(int a , int b , int c); void print();};//使用初始化列表的方式初始化构造函数里的私有环境变量 ScreenRecoveryUI::ScreenRecoveryUI(): r(0), g(0), b(0), p(nullptr){ for(int i = 0 ; i < 10 ; i++){ buffer[i] = 0 ; }} void ScreenRecoveryUI::setvalue(int a ,int b , int c){ this->r = a ; this->g = b ; this->b = c ;}void ScreenRecoveryUI::print(){ cout << "r:" << this->r << endl << "g:" << this->g << endl << "b:" << b << endl ; }int main(void){ ScreenRecoveryUI screen ; screen.setvalue(255,255,0); screen.print(); return 0 ;} |
运行结果：
r:255
g:255
b:0
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对服务器之家的支持。如果你想了解更多相关内容请查看下面相关链接
原文链接：https://blog.csdn.net/morixinguan/article/details/74331335
