上一篇我们讲到了服务端启动的流程，本篇主要讲解主要升级流程，UpdateAttempterAndroid类包含的内容较多，所以单独讲解，这个文件看了很长时间，大概方法都已经了解，但是想了很久从哪儿开始梳理这个流程，不仅仅是我能看懂，而且能讲出来的很清晰，这是我想做到的，别问，问就是重点
一、update_attempter_android.h 简要分析
1、继承和构造函数
1class UpdateAttempterAndroid
2 : public ServiceDelegateAndroidInterface,
3 public ActionProcessorDelegate,
4 public DownloadActionDelegate,
5 public PostinstallRunnerAction::DelegateInterface {
6 public:
7 using UpdateStatus = update_engine::UpdateStatus;
8
9 UpdateAttempterAndroid(DaemonStateInterface* daemon_state,
10 PrefsInterface* prefs,
11 BootControlInterface* boot_control_,
12 HardwareInterface* hardware_);
13 ~UpdateAttempterAndroid() override;
UpdateAttempterAndroid继承了四个类
ServiceDelegateAndroidInterface
BinderUpdateEngineAndroidService具体执行的方法，由ServiceDelegateAndroidInterface类service_delegate执行，而具体执行的时候会执行子类UpdateAttempterAndroid的方法
ActionProcessorDelegate
Action机制的管理者
DownloadActionDelegate
具体升级业务DownloadAction
PostinstallRunnerAction
具体升级业务PostinstallRunnerAction
构造函数包含：DaemonStateInterface PrefsInterface BootControlInterface HardwareInterface
由上一篇分析我们知道，这些参数都是由DaemonStateAndroid传进来的指针对象
2、父类ServiceDelegateAndroidInterface的方法
1 // ServiceDelegateAndroidInterface overrides. 2 // 通过binder_service 调用的方法，也就是客户端直接发出的方法 3 bool ApplyPayload(const std::string& payload_url, 4 int64_t payload_offset, 5 int64_t payload_size, 6 const std::vector<std::string>& key_value_pair_headers, 7 brillo::ErrorPtr* error) override; 8 bool SuspendUpdate(brillo::ErrorPtr* error) override; 9 bool ResumeUpdate(brillo::ErrorPtr* error) override; 10 bool CancelUpdate(brillo::ErrorPtr* error) override; 11 bool ResetStatus(brillo::ErrorPtr* error) override; 12 bool VerifyPayloadApplicable(const std::string& metadata_filename, 13 brillo::ErrorPtr* error) override;
3、父类ActionProcessorDelegate的方法
1 // ActionProcessorDelegate methods: 2 // 需要使用到的ActionProcessor的方法 3 void ProcessingDone(const ActionProcessor* processor, 4 ErrorCode code) override; 5 void ProcessingStopped(const ActionProcessor* processor) override; 6 void ActionCompleted(ActionProcessor* processor, 7 AbstractAction* action, 8 ErrorCode code) override;
4、父类DownloadAction和PostinstallRunnerAction的方法
1 // DownloadActionDelegate overrides. 2 // DownloadAction相关的方法 3 void BytesReceived(uint64_t bytes_progressed, 4 uint64_t bytes_received, 5 uint64_t total) override; 6 bool ShouldCancel(ErrorCode* cancel_reason) override; 7 void DownloadComplete() override; 8 9 // PostinstallRunnerAction::DelegateInterface 10 // PostinstallRunnerAction相关的方法 11 void ProgressUpdate(double progress) override;
5、私有方法
1 private:
2 //friend关键字其实做这样的事情：在一个类中指明其他的类（或者）函数能够直接访问该类中的private和protected成员。
3 friend class UpdateAttempterAndroidTest;
4
5 // Asynchronously marks the current slot as successful if needed. If already
6 // marked as good, CompleteUpdateBootFlags() is called starting the action
7 // processor.
8 // 如果需要，将当前插槽异步标记为成功。 如果已经标记为良好，则调用CompleteUpdateBootFlags（）启动操作处理器。
9 void UpdateBootFlags();
10
11 // Called when the boot flags have been updated.
12 // 引导标志已更新时调用。
13 void CompleteUpdateBootFlags(bool success);
14
15 // Schedules an event loop callback to start the action processor. This is
16 // scheduled asynchronously to unblock the event loop.
17 // 调度事件循环回调以启动动作处理器。 这是异步安排的，以取消阻塞事件循环。
18 void ScheduleProcessingStart();
19
20 // Notifies an update request completed with the given error |code| to all
21 // observers.
22 //通知更新请求已完成，并带有给定错误| code | 对所有观察者。
23 void TerminateUpdateAndNotify(ErrorCode error_code);
24
25 // Sets the status to the given |status| and notifies a status update to
26 // all observers.
27 // 将状态设置为给定的| status | 并将状态更新通知所有观察者。
28 void SetStatusAndNotify(UpdateStatus status);
29
30 // Helper method to construct the sequence of actions to be performed for
31 // applying an update from the given |url|.
32 // Helper方法，用于根据给定的| url |构造要应用更新的操作序列。
33 void BuildUpdateActions(const std::string& url);
34
35 // Writes to the processing completed marker. Does nothing if
36 // |update_completed_marker_| is empty.
37 // 写入处理完成标记，如果update_completed_marker_ 是空的，那什么都不做
38 bool WriteUpdateCompletedMarker();
39
40 // Returns whether an update was completed in the current boot.
41 // 返回更新是否在当前引导中完成。
42 bool UpdateCompletedOnThisBoot();
43
44 // prefs相关的方法
45 // Prefs to use for metrics report
46 // |kPrefsPayloadAttemptNumber|: number of update attempts for the current
47 // payload_id.
48 // |KprefsNumReboots|: number of reboots when applying the current update.
49 // |kPrefsSystemUpdatedMarker|: end timestamp of the last successful update.
50 // |kPrefsUpdateTimestampStart|: start timestamp of the current update.
51 // |kPrefsCurrentBytesDownloaded|: number of bytes downloaded for the current
52 // payload_id.
53 // |kPrefsTotalBytesDownloaded|: number of bytes downloaded in total since
54 // the last successful update.
55
56 // Metrics report function to call:
57 // |ReportUpdateAttemptMetrics|
58 // |ReportSuccessfulUpdateMetrics|
59 // Prefs to update:
60 // |kPrefsSystemUpdatedMarker|
61 void CollectAndReportUpdateMetricsOnUpdateFinished(ErrorCode error_code);
62
63 // Metrics report function to call:
64 // |ReportAbnormallyTerminatedUpdateAttemptMetrics|
65 // |ReportTimeToRebootMetrics|
66 // Prefs to update:
67 // |kPrefsBootId|, |kPrefsPreviousVersion|
68 void UpdatePrefsAndReportUpdateMetricsOnReboot();
69
70 // Prefs to update:
71 // |kPrefsPayloadAttemptNumber|, |kPrefsUpdateTimestampStart|
72 void UpdatePrefsOnUpdateStart(bool is_resume);
73
74 // Prefs to delete:
75 // |kPrefsNumReboots|, |kPrefsPayloadAttemptNumber|,
76 // |kPrefsSystemUpdatedMarker|, |kPrefsUpdateTimestampStart|,
77 // |kPrefsCurrentBytesDownloaded|
78 void ClearMetricsPrefs();
79
80 //daemon_state_指针，在成员变量中
81 DaemonStateInterface* daemon_state_;
82
83 // DaemonStateAndroid pointers.
84 // DaemonStateAndroid传入的指针
85 PrefsInterface* prefs_;
86 BootControlInterface* boot_control_;
87 HardwareInterface* hardware_;
88
89 // Last status notification timestamp used for throttling. Use monotonic
90 // TimeTicks to ensure that notifications are sent even if the system clock is
91 // set back in the middle of an update.
92 // 于限制的最后状态通知时间戳。 使用单调TimeTicks，以确保即使在更新过程中重新设置系统时钟，也可以发送通知。
93 base::TimeTicks last_notify_time_;
94
95 // The list of actions and action processor that runs them asynchronously.
96 // Only used when |ongoing_update_| is true.
97 // actions_ action的列表，状态在ongoing_update_ = true的时候执行
98 std::vector<std::shared_ptr<AbstractAction>> actions_;
99 // processor_ ActionProcessor管理者
100 std::unique_ptr<ActionProcessor> processor_;
101
102 // Pointer to the DownloadAction in the actions_ vector.
103 // DownloadAction的指针
104 std::shared_ptr<DownloadAction> download_action_;
105
106 // Whether there is an ongoing update. This implies that an update was started
107 // but not finished yet. This value will be true even if the update was
108 // suspended.
109 bool ongoing_update_{false};
110
111 // The InstallPlan used during the ongoing update.
112 InstallPlan install_plan_;
113
114 // For status:
115 UpdateStatus status_{UpdateStatus::IDLE};
116 double download_progress_{0.0};
117
118 // The offset in the payload file where the CrAU part starts.
119 int64_t base_offset_{0};
120
121 // Only direct proxy supported.
122 DirectProxyResolver proxy_resolver_;
123
124 // Helper class to select the network to use during the update.
125 std::unique_ptr<NetworkSelectorInterface> network_selector_;
126
127 // Whether we have marked the current slot as good. This step is required
128 // before applying an update to the other slot.
129 bool updated_boot_flags_ = false;
130
131 std::unique_ptr<ClockInterface> clock_;
132
133 std::unique_ptr<MetricsReporterInterface> metrics_reporter_;
134
135 DISALLOW_COPY_AND_ASSIGN(UpdateAttempterAndroid);
是的，方法就是这么多，别问，问都是重点，多我们就继续拆分成模块分析就行了
二、update_attempter_android.cc 分析
先从最后启动服务端的时候执行的
1bool DaemonStateAndroid::StartUpdater() {
2 // The DaemonState in Android is a passive daemon. It will only start applying
3 // an update when instructed to do so from the exposed binder API.
4 update_attempter_->Init();
5 return true;
6}
开始接着分析
1、init 和 UpdateCompletedOnThisBoot方法
1//首先还是层接daemon_state_android.cc执行的StartUpdater中执行init
2void UpdateAttempterAndroid::Init() {
3 // In case of update_engine restart without a reboot we need to restore the
4 // reboot needed state.
5 //判断是不是已经更新完成了
6 if (UpdateCompletedOnThisBoot()) {
7 //如果是，给客户端返回状态为UPDATED_NEED_REBOOT
8 SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
9 } else {
10 //如果没有更新完成，返回状态IDLE，表示为空闲状态
11 SetStatusAndNotify(UpdateStatus::IDLE);
12 UpdatePrefsAndReportUpdateMetricsOnReboot();
13 }
14}
15
16//判断是不是升级成功 对比当前机器的boot_id 和升级完成需要重启的boot_id
17//如果对比相同，那么判定为升级成功
18bool UpdateAttempterAndroid::UpdateCompletedOnThisBoot() {
19 // In case of an update_engine restart without a reboot, we stored the boot_id
20 // when the update was completed by setting a pref, so we can check whether
21 // the last update was on this boot or a previous one.
22 string boot_id;
23 TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
24
25 string update_completed_on_boot_id;
26 return (prefs_->Exists(kPrefsUpdateCompletedOnBootId) &&
27 prefs_->GetString(kPrefsUpdateCompletedOnBootId,
28 &update_completed_on_boot_id) &&
29 update_completed_on_boot_id == boot_id);
30}
31
32// Save the update start time. Reset the reboot count and attempt number if the
33// update isn't a resume; otherwise increment the attempt number.
34// 保存更新开始时间。 如果更新不是恢复操作，请重置重启次数和尝试次数； 否则增加尝试次数。
35void UpdateAttempterAndroid::UpdatePrefsOnUpdateStart(bool is_resume) {
36 if (!is_resume) {
37 metrics_utils::SetNumReboots(0, prefs_);
38 metrics_utils::SetPayloadAttemptNumber(1, prefs_);
39 } else {
40 int64_t attempt_number =
41 metrics_utils::GetPersistedValue(kPrefsPayloadAttemptNumber, prefs_);
42 metrics_utils::SetPayloadAttemptNumber(attempt_number + 1, prefs_);
43 }
44 Time update_start_time = clock_->GetMonotonicTime();
45 metrics_utils::SetUpdateTimestampStart(update_start_time, prefs_);
46}
2、ApplyPayload方法
好吧，重点开始了，别问，问就是重点，拆分下来大概为以下几部主要流程：
1、判断升级状态
2、解析传入的参数
3、将传入的参数设定到install_plan_结构体
4、创建升级的各种action
5、回调给客户端当前升级状态
6、更新启动分区的标识
1//进入我们的正菜，这里其实就是核心方法开始执行了
2//url:升级包(Payload)的路径，ab升级只能使用内置存储，必须在目录 /data/ota_package/xxx 而且需要以file://开头，比如file://data/ota_package/update.zip
3//offset:这是payload 在update.zip中的偏移量，需要从升级包文件中计算出来
4//Size:这是payload文件的大小，可以在payload_properties.txt中找到
5//headerKeyValuePairs:这是metadata,可以在升级包中的payload_properties.txt中找到,
6//headerKeyValuePairs参数 时用来传输metadata数据给update_engine服务端，存储在payload_properties.txt，通过脚本system/update_engine/scripts/brillo_update_payload
7// 生成，数据格式如下：
8//String[] pairs = {
9// "FILE_HASH=f1KT8nZAvNCx7hesGI0xaqVm9CIWzQvXGfg2T2Cp+ME=",
10// "FILE_SIZE=781070526",
11// "METADATA_HASH=lMosFzUjtB1ODkiSTw4xgNt6WkYuGV70GzTkdNTtlMU=",
12// "METADATA_SIZE=89254"
13//};
14bool UpdateAttempterAndroid::ApplyPayload(
15 const string& payload_url,
16 int64_t payload_offset,
17 int64_t payload_size,
18 const vector<string>& key_value_pair_headers,
19 brillo::ErrorPtr* error) {
20 //1、判断升级状态
21 //判断是否已经升级完成，如果是，那么不需要在走下面的升级流程
22 if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {
23 return LogAndSetError(
24 error, FROM_HERE, "An update already applied, waiting for reboot");
25 }
26 //判断是不是正在升级，ongoing_update_ 是正在升级的意思，如果是正在升级，不需要走下面的升级流程
27 if (ongoing_update_) {
28 return LogAndSetError(
29 error, FROM_HERE, "Already processing an update, cancel it first.");
30 }
31 //检查状态是不是IDIE
32 DCHECK(status_ == UpdateStatus::IDLE);
33 //2、解析传入的参数
34 //创建map集合
35 std::map<string, string> headers;
36 for (const string& key_value_pair : key_value_pair_headers) {
37 string key;
38 string value;
39 if (!brillo::string_utils::SplitAtFirst(
40 key_value_pair, "=", &key, &value, false)) {
41 return LogAndSetError(
42 error, FROM_HERE, "Passed invalid header: " + key_value_pair);
43 }
44 //将传入的key value放入到headers 这个map集合中
45 if (!headers.emplace(key, value).second)
46 return LogAndSetError(error, FROM_HERE, "Passed repeated key: " + key);
47 }
48
49 // Unique identifier for the payload. An empty string means that the payload
50 // can't be resumed.
51 // 根据headers中的FileHash 和 MetadataHash 组成payload_id
52 string payload_id = (headers[kPayloadPropertyFileHash] +
53 headers[kPayloadPropertyMetadataHash]);
54
55 // Setup the InstallPlan based on the request.
56 //创建install_plan_ 查询了install_plan.h的代码，InstallPlan是一个struct结构体
57 //既然是结构体，那么就包含了很多需要设定的参数，以下就是设定他的一些参数
58 //3、将传入的参数设定到install_plan_结构体
59 install_plan_ = InstallPlan();
60 install_plan_.download_url = payload_url;
61 install_plan_.version = "";
62 base_offset_ = payload_offset;
63 InstallPlan::Payload payload;
64 payload.size = payload_size;
65 if (!payload.size) {
66 if (!base::StringToUint64(headers[kPayloadPropertyFileSize],
67 &payload.size)) {
68 payload.size = 0;
69 }
70 }
71 if (!brillo::data_encoding::Base64Decode(headers[kPayloadPropertyFileHash],
72 &payload.hash)) {
73 LOG(WARNING) << "Unable to decode base64 file hash: "
74 << headers[kPayloadPropertyFileHash];
75 }
76 if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],
77 &payload.metadata_size)) {
78 payload.metadata_size = 0;
79 }
80 // The |payload.type| is not used anymore since minor_version 3.
81 payload.type = InstallPayloadType::kUnknown;
82 //为payload赋值后放入install_plan_.payloads容器中
83 install_plan_.payloads.push_back(payload);
84
85 // The |public_key_rsa| key would override the public key stored on disk.
86 install_plan_.public_key_rsa = "";
87 //是否强制性校验hash
88 install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild();
89 //判断是否进行未完成的升级
90 install_plan_.is_resume = !payload_id.empty() &&
91 DeltaPerformer::CanResumeUpdate(prefs_, payload_id);
92 if (!install_plan_.is_resume) {
93 if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) {
94 LOG(WARNING) << "Unable to reset the update progress.";
95 }
96 if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) {
97 LOG(WARNING) << "Unable to save the update check response hash.";
98 }
99 }
100 //当前正在运行的分区
101 install_plan_.source_slot = boot_control_->GetCurrentSlot();
102 //需要升级的分区
103 install_plan_.target_slot = install_plan_.source_slot == 0 ? 1 : 0;
104
105 install_plan_.powerwash_required =
106 GetHeaderAsBool(headers[kPayloadPropertyPowerwash], false);
107 //选择那个分区进行重启
108 install_plan_.switch_slot_on_reboot =
109 GetHeaderAsBool(headers[kPayloadPropertySwitchSlotOnReboot], true);
110
111 install_plan_.run_post_install = true;
112 // Optionally skip post install if and only if:
113 // a) we're resuming
114 // b) post install has already succeeded before
115 // c) RUN_POST_INSTALL is set to 0.
116 if (install_plan_.is_resume && prefs_->Exists(kPrefsPostInstallSucceeded)) {
117 bool post_install_succeeded = false;
118 prefs_->GetBoolean(kPrefsPostInstallSucceeded, &post_install_succeeded);
119 if (post_install_succeeded) {
120 install_plan_.run_post_install =
121 GetHeaderAsBool(headers[kPayloadPropertyRunPostInstall], true);
122 }
123 }
124
125 NetworkId network_id = kDefaultNetworkId;
126 if (!headers[kPayloadPropertyNetworkId].empty()) {
127 if (!base::StringToUint64(headers[kPayloadPropertyNetworkId],
128 &network_id)) {
129 return LogAndSetError(
130 error,
131 FROM_HERE,
132 "Invalid network_id: " + headers[kPayloadPropertyNetworkId]);
133 }
134 if (!network_selector_->SetProcessNetwork(network_id)) {
135 return LogAndSetError(
136 error,
137 FROM_HERE,
138 "Unable to set network_id: " + headers[kPayloadPropertyNetworkId]);
139 }
140 }
141
142 LOG(INFO) << "Using this install plan:";
143 //一直到这里，参数终于设定完了，这个方法是install_plan.cc中的，相当于遍历输出了结构体中所有的内容
144 install_plan_.Dump();
145
146 //4、创建升级的各种action
147 BuildUpdateActions(payload_url);
148 // Setup extra headers.设定了两个额外的参数
149 HttpFetcher* fetcher = download_action_->http_fetcher();
150 if (!headers[kPayloadPropertyAuthorization].empty())
151 fetcher->SetHeader("Authorization", headers[kPayloadPropertyAuthorization]);
152 if (!headers[kPayloadPropertyUserAgent].empty())
153 fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);
154 //5、回调给客户端当前升级状态为UPDATE_AVAILABLE
155 SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
156 //设定标志为正在更新
157 ongoing_update_ = true;
158
159 // Just in case we didn't update boot flags yet, make sure they're updated
160 // before any update processing starts. This will start the update process.
161 //6、更新启动分区的标识
162 UpdateBootFlags();
163
164 UpdatePrefsOnUpdateStart(install_plan_.is_resume);
165 // TODO(xunchang) report the metrics for unresumable updates
166
167 return true;
168}
3、BuildUpdateActions(payload_url)方法
说明这个方法之前先讲解以下update_engine的Action机制和ActionProcessor类,大概了解Action之后之后的方法理解起来会容易一些
3.1 Action机制
是的，我是从网上直接copy的，因为我觉得概念总结的很全面，所以直接抄了
出处：https://blog.csdn.net/guyongqiangx/article/details/82226079
Action机制是整个Update Engine服务端进程运行的核心，不清楚Action机制，就无法了解整个Update Engine服务端是如何运作的。
Action机制主要有三个部分组成: Action, ActionProcessor和ActionPipe。
3.1.1 Action
基于Action机制，Update Engine里面的每一个任务都被封装为一个Action，例如下载任务被封装为DownloadAction, 文件系统验证的任务被封装为FilesystemVerifierAction，更新完成后所有收尾动作被封装为PostinstallRunnerAction。
当然，这个Action机制很灵活，你甚至可以根据需要定义自己特有的Action。例如，将数据解密的操作定义为DecryptAction，在DownloadAction下载完数据后需要先通过DecryptAction将数据解密，再将解密后的数据送往下一个操作。
总之，Action就是一个基本的任务单元。
Update Engine代码中，默认定义了4个Action，分别为：InstallPlanAction, DownloadAction, FilesystemVerifierAction, PostinstallRunnerAction。这些Action的名字都很直观，见名知意。
单个Action执行的时间不是固定的。例如，基于不同的网络状况，有的DownloadAction很快就可以完成，但有的DownloadAction可能需要很久。因此代码上，Action都是异步执行的，对Action调用PerformAction()使其开始工作，但这个函数返回只表明Action开始了，并不代表执行结束（有可能结束，也有可能刚开始）。
例如DownloadAction，调用PerformAction()对数据下载进行初始化设置，然后底层的数据传输开始工作，函数返回时数据传输并没有完成。在数据传输完成时底层会触发调用TransferComplete()进行通知。
3.1.2 Action Processor
既然Update Engine里定义了多个Action，那这些Action是如何组织运行的呢？此时就需要有一个Action的管理者，这就是ActionProcessor.
在ActionProcessor里面定义了一个Action的队列, 在Update Engine准备更新时，会根据当前传入的参数构造多个Action并放入ActionProcessor的Action队列。
除了Action队列，ActionProcessor中还有一个指针，用于指示当前正在运行的Action。
ActionProcessor通过StartProcessing()操作开始工作，先挑选队列中的第一个Action作为当前Action。然后当前Action调用PerformAction()开始工作，Action结束后会调用ActionProcessor的ActionComplete()接口通知当前Action已经完成。随后ActionProcessor通过StartNextActionOrFinish()挑选队列中的下一个Action进行操作。循环往复，直到队列中的所有Action都完成操作。
3.1.3 Action Pipe
类似于Unix系统的管道，Action机制中，也会通过管道ActionPipe将这些Action链接在一起。上一个Action的输出会作为下一个Action的输入。
因此在Update Engine中，所有的Action之间有一个先后关系。例如，只有DownloadAction完成操作了，才能开始FilesystemVerifierAction操作；也只有FilesystemVerifierAction结束了，才会开始PostinstallRunnerAction操作。
3.2 Action基类AbstractAction
本来是准备直接分析ActionProcessor，发现还是要从最基础的开始，相当于我们看了半天菜谱，没看食材，所以对AbstractAction做一个简单的分析，同时我们也看到了Action机制大概的概念
这里我们要注意的是，AbstractAction中定义的虚函数，每个具体的action都会重写该抽象类中的开始，停止，执行action等方法
1update_engine/common/action.h
2// 你看这注释的多详细
3// The structure of these classes (Action, ActionPipe, ActionProcessor, etc.)
4// is based on the KSAction* classes from the Google Update Engine code at
5// http://code.google.com/p/update-engine/ . The author of this file sends
6// a big thanks to that team for their high quality design, implementation,
7// and documentation.
8//
9// Readers may want to consult this wiki page from the Update Engine site:
10// http://code.google.com/p/update-engine/wiki/ActionProcessor
11// Although it's referring to the Objective-C KSAction* classes, much
12// applies here as well.
13//
14// How it works:
15//
16// First off, there is only one thread and all I/O should be asynchronous.
17// A message loop blocks whenever there is no work to be done. This happens
18// where there is no CPU work to be done and no I/O ready to transfer in or
19// out. Two kinds of events can wake up the message loop: timer alarm or file
20// descriptors. If either of these happens, the message loop finds out the owner
21// of what fired and calls the appropriate code to handle it. As such, all the
22// code in the Action* classes and the code that is calls is non-blocking.
23//
24// An ActionProcessor contains a queue of Actions to perform. When
25// ActionProcessor::StartProcessing() is called, it executes the first action.
26// Each action tells the processor when it has completed, which causes the
27// Processor to execute the next action. ActionProcessor may have a delegate
28// (an object of type ActionProcessorDelegate). If it does, the delegate
29// is called to be notified of events as they happen.
30//
31// ActionPipe classes
32//
33// See action_pipe.h
34//
35// ActionTraits
36//
37// We need to use an extra class ActionTraits. ActionTraits is a simple
38// templated class that contains only two typedefs: OutputObjectType and
39// InputObjectType. Each action class also has two typedefs of the same name
40// that are of the same type. So, to get the input/output types of, e.g., the
41// DownloadAction class, we look at the type of
42// DownloadAction::InputObjectType.
43//
44// Each concrete Action class derives from Action<T>. This means that during
45// template instantiation of Action<T>, T is declared but not defined, which
46// means that T::InputObjectType (and OutputObjectType) is not defined.
47// However, the traits class is constructed in such a way that it will be
48// template instantiated first, so Action<T> *can* find the types it needs by
49// consulting ActionTraits<T>::InputObjectType (and OutputObjectType).
50// This is why the ActionTraits classes are needed.
51
52namespace chromeos_update_engine {
53
54// It is handy to have a non-templated base class of all Actions.
55// 拥有所有Actions的非模板基类
56class AbstractAction {
57 public:
58 AbstractAction() : processor_(nullptr) {}
59 virtual ~AbstractAction() = default;
60
61 // Begin performing the action. Since this code is asynchronous, when this
62 // method returns, it means only that the action has started, not necessarily
63 // completed. However, it's acceptable for this method to perform the
64 // action synchronously; Action authors should understand the implications
65 // of synchronously performing, though, because this is a single-threaded
66 // app, the entire process will be blocked while the action performs.
67 //
68 // When the action is complete, it must call
69 // ActionProcessor::ActionComplete(this); to notify the processor that it's
70 // done.
71 // 开始执行操作。 由于此代码是异步的，因此当此方法返回时，仅意味着该动作已开始，不一定完成。
72 // 但是，此方法可以同步执行操作，这是可以接受的； 但是，动作作者应该了解同步执行的含义，
73 // 因为这是一个单线程应用程序，所以动作执行时会阻塞整个过程。
74 // 操作完成后，必须调用ActionProcessor::ActionComplete（this）;通知处理器已完成。
75 virtual void PerformAction() = 0;
76
77 // Called on ActionProcess::ActionComplete() by ActionProcessor.
78 // 执行ActionProcessor的ActionProcess::ActionComplete()时调用该方法
79 virtual void ActionCompleted(ErrorCode code) {}
80
81 // Called by the ActionProcessor to tell this Action which processor
82 // it belongs to.
83 // 由ActionProcessor调用以说明这个Action属于那个processor
84 void SetProcessor(ActionProcessor* processor) {
85 if (processor)
86 CHECK(!processor_);
87 else
88 CHECK(processor_);
89 processor_ = processor;
90 }
91
92 // Returns true iff the action is the current action of its ActionProcessor.
93 // 返回true 如果这个action 是ActionProcessor的当前的action
94 bool IsRunning() const {
95 if (!processor_)
96 return false;
97 return processor_->current_action() == this;
98 }
99
100 // Called on asynchronous actions if canceled. Actions may implement if
101 // there's any cleanup to do. There is no need to call
102 // ActionProcessor::ActionComplete() because the processor knows this
103 // action is terminating.
104 // Only the ActionProcessor should call this.
105 // 只有ActionProcessor 可以调用该方法
106 virtual void TerminateProcessing() {}
107
108 // Called on asynchronous actions if the processing is suspended and resumed,
109 // respectively. These methods are called by the ActionProcessor and should
110 // not be explicitly called.
111 // The action may still call ActionCompleted() once the action is completed
112 // while the processing is suspended, for example if suspend/resume is not
113 // implemented for the given action.
114 virtual void SuspendAction() {}
115 virtual void ResumeAction() {}
116
117 // These methods are useful for debugging. TODO(adlr): consider using
118 // std::type_info for this?
119 // Type() returns a string of the Action type. I.e., for DownloadAction,
120 // Type() would return "DownloadAction".
121 virtual std::string Type() const = 0;
122
123 protected:
124 // A weak pointer to the processor that owns this Action.
125 ActionProcessor* processor_;
126};
127
128// Forward declare a couple classes we use.
129template<typename T>
130class ActionPipe;
131template<typename T>
132class ActionTraits;
133
134//Action类继承了AbstractAction类
135//这里面涉及到Action pipe一些方法操作
136template<typename SubClass>
137class Action : public AbstractAction {
138 public:
139 ~Action() override {}
140
141 // Attaches an input pipe to this Action. This is optional; an Action
142 // doesn't need to have an input pipe. The input pipe must be of the type
143 // of object that this class expects.
144 // This is generally called by ActionPipe::Bond()
145 // 将输入管道附加到此动作。 这是可选的； 一种Action不需要输入管道。 输入管道必须为该类期望的对象。
146 // 通常由ActionPipe :: Bond（）调用
147 void set_in_pipe(
148 // this type is a fancy way of saying: a shared_ptr to an
149 // ActionPipe<InputObjectType>.
150 const std::shared_ptr<ActionPipe<
151 typename ActionTraits<SubClass>::InputObjectType>>& in_pipe) {
152 in_pipe_ = in_pipe;
153 }
154
155 // Attaches an output pipe to this Action. This is optional; an Action
156 // doesn't need to have an output pipe. The output pipe must be of the type
157 // of object that this class expects.
158 // This is generally called by ActionPipe::Bond()
159 void set_out_pipe(
160 // this type is a fancy way of saying: a shared_ptr to an
161 // ActionPipe<OutputObjectType>.
162 const std::shared_ptr<ActionPipe<
163 typename ActionTraits<SubClass>::OutputObjectType>>& out_pipe) {
164 out_pipe_ = out_pipe;
165 }
166
167 // Returns true iff there is an associated input pipe. If there's an input
168 // pipe, there's an input object, but it may have been constructed with the
169 // default ctor if the previous action didn't call SetOutputObject().
170 // 如果存在关联的输入管道，则返回true。 如果有输入管道中有一个输入对象，
171 // 但如果先前的action未调用SetOutputObject（），则可能已使用默认ctor构造了该对象。
172 bool HasInputObject() const { return in_pipe_.get(); }
173
174 // returns a const reference to the object in the input pipe.
175 // 返回对输入管道中对象的const引用。
176 const typename ActionTraits<SubClass>::InputObjectType& GetInputObject()
177 const {
178 CHECK(HasInputObject());
179 return in_pipe_->contents();
180 }
181
182 // Returns true iff there's an output pipe.
183 // 如果有输出管道，返回true
184 bool HasOutputPipe() const {
185 return out_pipe_.get();
186 }
187
188 // Copies the object passed into the output pipe. It will be accessible to
189 // the next Action via that action's input pipe (which is the same as this
190 // Action's output pipe).
191 // 复制传递到输出管道中的对象,下一个动作可以通过该动作的输入管道（与该动作的输出管道相同）进行访问。
192 void SetOutputObject(
193 const typename ActionTraits<SubClass>::OutputObjectType& out_obj) {
194 CHECK(HasOutputPipe());
195 out_pipe_->set_contents(out_obj);
196 }
197
198 // Returns a reference to the object sitting in the output pipe.
199 const typename ActionTraits<SubClass>::OutputObjectType& GetOutputObject() {
200 CHECK(HasOutputPipe());
201 return out_pipe_->contents();
202 }
203
204 protected:
205 // We use a shared_ptr to the pipe. shared_ptr objects destroy what they
206 // point to when the last such shared_ptr object dies. We consider the
207 // Actions on either end of a pipe to "own" the pipe. When the last Action
208 // of the two dies, the ActionPipe will die, too.
209 std::shared_ptr<ActionPipe<typename ActionTraits<SubClass>::InputObjectType>>
210 in_pipe_;
211 std::shared_ptr<ActionPipe<typename ActionTraits<SubClass>::OutputObjectType>>
212 out_pipe_;
213};
3.3 ActionProcessor类
看了这一大段概念后，很明显ActionProcessor是分析的重点
我们大概看下这个文件的代码和相关的方法定义
3.3.1 action_processor.h 分析
1update_engine/common/action_processor.h
2
3class ActionProcessor {
4 public:
5 ActionProcessor() = default;
6
7 virtual ~ActionProcessor();
8
9 // Starts processing the first Action in the queue. If there's a delegate,
10 // when all processing is complete, ProcessingDone() will be called on the
11 // delegate.
12 // 开始处理队列中的第一个Action。 如果有代表，
13 // 当所有处理完成后，将在委托上调用ProcessingDone（）。
14 // 定义开始方法
15 virtual void StartProcessing();
16
17 // Aborts processing. If an Action is running, it will have
18 // TerminateProcessing() called on it. The Action that was running and all the
19 // remaining actions will be lost and must be re-enqueued if this Processor is
20 // to use it.
21 // 中止处理。 如果某个动作正在运行，它将具有调用TerminateProcessing（）。 如果此处理器要使用它，
22 // 则正在运行的动作以及所有其他剩余动作将丢失，必须重新排队。
23 // 定义结束方法
24 void StopProcessing();
25
26 // Suspend the processing. If an Action is running, it will have the
27 // SuspendProcessing() called on it, and it should suspend operations until
28 // ResumeProcessing() is called on this class to continue. While suspended,
29 // no new actions will be started. Calling SuspendProcessing while the
30 // processing is suspended or not running this method performs no action.
31 // 暂停处理。 如果某个Action正在运行，它将具有SuspendProcessing（）对其进行了调用，
32 // 它应该挂起操作，直到对该类调用ResumeProcessing（）继续。
33 // 在暂停期间，不会启动任何新动作,在处理暂停或不运行此方法时调用SuspendProcessing不会执行任何操作。
34 // 定义暂停方法
35 void SuspendProcessing();
36
37 // Resume the suspended processing. If the ActionProcessor is not suspended
38 // or not running in the first place this method performs no action.
39 // 恢复暂停的处理。 如果ActionProcessor没有被挂起或没有首先运行，则此方法不执行任何操作。
40 // 定义恢复方法
41 void ResumeProcessing();
42
43 // Returns true if the processing was started but not yet completed nor
44 // stopped.
45 // 定义一个判断条件，是不是正在运行或者是不是状态
46 bool IsRunning() const { return current_action_ != nullptr || suspended_; }
47
48 // Adds another Action to the end of the queue.
49 // 将Action方入队列
50 virtual void EnqueueAction(AbstractAction* action);
51
52 // Sets/gets the current delegate. Set to null to remove a delegate.
53 // 设置一个代理委托，注意，update_engine很多地方都用到了这个思路
54 ActionProcessorDelegate* delegate() const { return delegate_; }
55 void set_delegate(ActionProcessorDelegate *delegate) {
56 delegate_ = delegate;
57 }
58
59 // Returns a pointer to the current Action that's processing.
60 // 返回当前正在运行的Action
61 AbstractAction* current_action() const {
62 return current_action_;
63 }
64
65 // Called by an action to notify processor that it's done. Caller passes self.
66 // Action完成后通知ActionProcessor完成了
67 void ActionComplete(AbstractAction* actionptr, ErrorCode code);
68
69 private:
70 // Continue processing actions (if any) after the last action terminated with
71 // the passed error code. If there are no more actions to process, the
72 // processing will terminate.
73 // 在上一个操作以传递的错误代码终止后，继续处理操作（如果有）。
74 // 如果没有更多要处理的操作，则处理将终止。
75 // 定义继续下一个Action还是结束的方法
76 void StartNextActionOrFinish(ErrorCode code);
77
78 // Actions that have not yet begun processing, in the order in which
79 // they'll be processed.
80 // Action还没有开始处理，定义一个对接，放入
81 std::deque<AbstractAction*> actions_;
82
83 // A pointer to the currently processing Action, if any.
84 // 定义一个指针指向正在运行的Action
85 AbstractAction* current_action_{nullptr};
86
87 // The ErrorCode reported by an action that was suspended but finished while
88 // being suspended. This error code is stored here to be reported back to the
89 // delegate once the processor is resumed.
90 // 由已暂停但在被暂停时完成的操作报告的ErrorCode。
91 // 此错误代码存储在此处，一旦处理器恢复，便会报告给委托人。
92 ErrorCode suspended_error_code_{ErrorCode::kSuccess};
93
94 // Whether the action processor is or should be suspended.
95 // 定义一个标志位，判断时候暂停状态
96 bool suspended_{false};
97
98 // A pointer to the delegate, or null if none.
99 // 定义委托的指针
100 ActionProcessorDelegate* delegate_{nullptr};
101
102 DISALLOW_COPY_AND_ASSIGN(ActionProcessor);
103};
104
105// A delegate object can be used to be notified of events that happen
106// in an ActionProcessor. An instance of this class can be passed to an
107// ActionProcessor to register itself.
108// 可以使用委托对象来通知发生的事件在ActionProcessor中。 此类的实例可以传递给ActionProcessor自行注册。
109// updateAttempter继承了ActionProcessorDelegate，所以会重写它的三个方法
110// 其实这个类的定义是我设置一个委托，在ActionProcessor中进行注册，这样用委托调用ActionProcessor的方法
111// 这样我可以调用到processtor的方法，也可以定义一些与外部类交互的方法，例如Action完成或者停止给客户端返回状态
112class ActionProcessorDelegate {
113 public:
114 virtual ~ActionProcessorDelegate() = default;
115
116 // Called when all processing in an ActionProcessor has completed. A pointer
117 // to the ActionProcessor is passed. |code| is set to the exit code of the
118 // last completed action.
119 // 当ActionProcessor中的所有处理完成时调用。 指向ActionProcessor的指针被传递。
120 // |代码| 设置为最后完成的操作的退出代码。
121 virtual void ProcessingDone(const ActionProcessor* processor,
122 ErrorCode code) {}
123
124 // Called when processing has stopped. Does not mean that all Actions have
125 // completed. If/when all Actions complete, ProcessingDone() will be called.
126 // 处理停止时调用。 并不意味着所有动作均已完成。 如果/当所有动作完成时，将调用ProcessingDone
127 virtual void ProcessingStopped(const ActionProcessor* processor) {}
128
129 // Called whenever an action has finished processing, either successfully
130 // or otherwise.
131 // 每当动作完成时调用，不管是成功或者其他
132 virtual void ActionCompleted(ActionProcessor* processor,
133 AbstractAction* action,
134 ErrorCode code) {}
135};
这里做一个简单的总结
定义ActionProcessor类 作为Action管理类，其中包含
Action放入队列
Action启动停止：StartProcessing StopProcessing
Action暂停恢复：SuspendProcessing ResumeProcessing
Action 完成和进行下一个：ActionComplete StartNextActionOrFinish
设置委托类：set_delegate
定义判定条件是否正在运行：IsRunning()
定义判断条件是否暂停状态：suspended_
定义ActionProcessorDelegate委托类
处理完成：ProcessingDone
处理停止：ProcessingStopped
Action完成：ActionCompleted
查看了大概的方法分类，我们去action_processor.cc文件中看下这些方法具体的实现
3.3.2 action_processor.cc文件分析
上面分析action_processor.h文件，下面.cc文件把大致的方法做了下讲解
1update_engine/common/action_processor.h
2
3ActionProcessor::~ActionProcessor() {
4 if (IsRunning())
5 StopProcessing();
6 for (auto action : actions_)
7 action->SetProcessor(nullptr);
8}
9
10//放入队列，actions_是存放adction的deque
11void ActionProcessor::EnqueueAction(AbstractAction* action) {
12 //将传入的action放入队列尾部
13 actions_.push_back(action);
14 //将现在的ActionProcessor 设置为action的ActionProcessor
15 action->SetProcessor(this);
16}
17
18//https://www.cnblogs.com/linuxAndMcu/p/10260124.html 关于C++ qedue的一些操作函数介绍
19//开始处理action
20void ActionProcessor::StartProcessing() {
21 //检查是不是当前没有运行
22 CHECK(!IsRunning());
23 //判断action对列中时候有action
24 if (!actions_.empty()) {
25 //从对接中取出第一个作为当前的action
26 current_action_ = actions_.front();
27 LOG(INFO) << "ActionProcessor: starting " << current_action_->Type();
28 //删除队列中的第一个元素，因为已经取出来了，所以删除了
29 actions_.pop_front();
30 //执行当前action
31 current_action_->PerformAction();
32 }
33}
34//停止处理action
35void ActionProcessor::StopProcessing() {
36 //检查是不是正在运行
37 CHECK(IsRunning());
38 //如果当前action存在
39 if (current_action_) {
40 //停止当前处理
41 current_action_->TerminateProcessing();
42 //不再与当前ActionProcessor关联
43 current_action_->SetProcessor(nullptr);
44 }
45 LOG(INFO) << "ActionProcessor: aborted "
46 << (current_action_ ? current_action_->Type() : "")
47 << (suspended_ ? " while suspended" : "");
48 //设置当前action为空，设置suspended标志位为false
49 current_action_ = nullptr;
50 suspended_ = false;
51 // Delete all the actions before calling the delegate.
52 // 清空action队列
53 for (auto action : actions_)
54 action->SetProcessor(nullptr);
55 actions_.clear();
56 //如果委托对象存在，调用委托对象的ProcessingStopped方法
57 //实际这里调用的就是UpdateAttempterAndroid的ProcessingStopped方法
58 if (delegate_)
59 delegate_->ProcessingStopped(this);
60}
61//暂停处理action
62void ActionProcessor::SuspendProcessing() {
63 // No current_action_ when not suspended means that the action processor was
64 // never started or already finished.
65 // 没有current_action_存在，说明processor没有启动或者已经结束，调用暂停就没有意义了
66 // 如果suspended_标志位是true，说明已经是暂停状态，直接return
67 if (suspended_ || !current_action_) {
68 LOG(WARNING) << "Called SuspendProcessing while not processing.";
69 return;
70 }
71 //设定暂停标志位为true
72 suspended_ = true;
73
74 // If there's a current action we should notify it that it should suspend, but
75 // the action can ignore that and terminate at any point.
76 // 暂停当前action
77 LOG(INFO) << "ActionProcessor: suspending " << current_action_->Type();
78 current_action_->SuspendAction();
79}
80//恢复处理action
81void ActionProcessor::ResumeProcessing() {
82 //如果suspended_就为false，说明没有暂停过，所以无需执行恢复操作
83 if (!suspended_) {
84 LOG(WARNING) << "Called ResumeProcessing while not suspended.";
85 return;
86 }
87 //设定暂停标志位为false
88 suspended_ = false;
89 //如果存在当前action
90 if (current_action_) {
91 // The current_action_ did not call ActionComplete while suspended, so we
92 // should notify it of the resume operation.
93 LOG(INFO) << "ActionProcessor: resuming " << current_action_->Type();
94 //执行恢复action操作
95 current_action_->ResumeAction();
96 } else {
97 // The last action called ActionComplete while suspended, so there is
98 // already a log message with the type of the finished action. We simply
99 // state that we are resuming processing and the next function will log the
100 // start of the next action or processing completion.
101 LOG(INFO) << "ActionProcessor: resuming processing";
102 //如果没有当前action,说明或者当前action处理完了，或者结束了
103 StartNextActionOrFinish(suspended_error_code_);
104 }
105}
106//action完成的操作
107void ActionProcessor::ActionComplete(AbstractAction* actionptr,
108 ErrorCode code) {
109 CHECK_EQ(actionptr, current_action_);
110 //如果委托对象存在
111 if (delegate_)
112 //执行委托对象的ActionCompleted，这里就是UpdateAttempterAndroid类的方法
113 delegate_->ActionCompleted(this, actionptr, code);
114 string old_type = current_action_->Type();
115 //执行action的ActionCompleted
116 current_action_->ActionCompleted(code);
117 current_action_->SetProcessor(nullptr);
118 //设置当前action为空
119 current_action_ = nullptr;
120 LOG(INFO) << "ActionProcessor: finished "
121 << (actions_.empty() ? "last action " : "") << old_type
122 << (suspended_ ? " while suspended" : "")
123 << " with code " << utils::ErrorCodeToString(code);
124 //如果action_对列中还有action而且结果不是成功
125 if (!actions_.empty() && code != ErrorCode::kSuccess) {
126 LOG(INFO) << "ActionProcessor: Aborting processing due to failure.";
127 //清空action_对列
128 actions_.clear();
129 }
130 //如果当前的已经执行完了，而且还是暂停状态，那就不用再执行下一个action,直接return
131 if (suspended_) {
132 // If an action finished while suspended we don't start the next action (or
133 // terminate the processing) until the processor is resumed. This condition
134 // will be flagged by a nullptr current_action_ while suspended_ is true.
135 suspended_error_code_ = code;
136 return;
137 }
138 //执行下一个action
139 StartNextActionOrFinish(code);
140}
141//执行下一个action或者结束
142void ActionProcessor::StartNextActionOrFinish(ErrorCode code) {
143 //如果action_为空
144 if (actions_.empty()) {
145 //执行delegate_也就是updateAttempterAndroid的方法ProcessingDone
146 if (delegate_) {
147 delegate_->ProcessingDone(this, code);
148 }
149 return;
150 }
151 //如果不为空，继续取出队列中的第一个作为当前的action
152 current_action_ = actions_.front();
153 //删除队列中的第一个元素
154 actions_.pop_front();
155 LOG(INFO) << "ActionProcessor: starting " << current_action_->Type();
156 //执行具体的action业务
157 current_action_->PerformAction();
158}
3.4 BuildUpdateAction方法分析
前面讲了一堆action相关的，再来看这个方法就比较好理解了
1//创建各类升级相关的action
2void UpdateAttempterAndroid::BuildUpdateActions(const string& url) {
3 //检查是不是没有执行action
4 CHECK(!processor_->IsRunning());
5 //1、将自身设置为委托对象，updateAttempterAndroid继承了ActionProcessorDelegate
6 processor_->set_delegate(this);
7
8 // Actions:
9 // 2、构建install_plan_action
10 shared_ptr<InstallPlanAction> install_plan_action(
11 new InstallPlanAction(install_plan_));
12 // 3、选择Http协议
13 HttpFetcher* download_fetcher = nullptr;
14 if (FileFetcher::SupportedUrl(url)) {
15 DLOG(INFO) << "Using FileFetcher for file URL.";
16 download_fetcher = new FileFetcher();
17 } else {
18#ifdef _UE_SIDELOAD
19 LOG(FATAL) << "Unsupported sideload URI: " << url;
20#else
21 LibcurlHttpFetcher* libcurl_fetcher =
22 new LibcurlHttpFetcher(&proxy_resolver_, hardware_);
23 libcurl_fetcher->set_server_to_check(ServerToCheck::kDownload);
24 download_fetcher = libcurl_fetcher;
25#endif // _UE_SIDELOAD
26 }
27 // 4、构建download_action
28 shared_ptr<DownloadAction> download_action(
29 new DownloadAction(prefs_,
30 boot_control_,
31 hardware_,
32 nullptr, // system_state, not used.
33 download_fetcher, // passes ownership
34 true /* is_interactive */));
35 // 5、构建filesystem_verifier_action
36 shared_ptr<FilesystemVerifierAction> filesystem_verifier_action(
37 new FilesystemVerifierAction());
38 // 6、构建PostinstallRunnerAction
39 shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
40 new PostinstallRunnerAction(boot_control_, hardware_));
41
42 download_action->set_delegate(this);
43 download_action->set_base_offset(base_offset_);
44 download_action_ = download_action;
45 postinstall_runner_action->set_delegate(this);
46
47 // 7、放入action_队列
48 actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
49 actions_.push_back(shared_ptr<AbstractAction>(download_action));
50 actions_.push_back(shared_ptr<AbstractAction>(filesystem_verifier_action));
51 actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
52
53 // Bond them together. We have to use the leaf-types when calling
54 // BondActions().
55 // 8、使用管道连接各个action
56 BondActions(install_plan_action.get(), download_action.get());
57 BondActions(download_action.get(), filesystem_verifier_action.get());
58 BondActions(filesystem_verifier_action.get(),
59 postinstall_runner_action.get());
60
61 // Enqueue the actions
62 // 将action放入队列
63 for (const shared_ptr<AbstractAction>& action : actions_)
64 processor_->EnqueueAction(action.get());
65}
4、UpdateBootFlags()方法
从这个方法的调用逻辑可以看出，在执行最后做了一个认为是安全保险的操作，将当前分区标记为成功启动分区，
然后开始了StartProcessing处理各种action
1//更新启动分区的标识
2void UpdateAttempterAndroid::UpdateBootFlags() {
3 //判断updated_boot_flags_不熬只为是否为true
4 if (updated_boot_flags_) {
5 LOG(INFO) << "Already updated boot flags. Skipping.";
6 //调用CompleteUpdateBootFlags 方法
7 CompleteUpdateBootFlags(true);
8 return;
9 }
10 // This is purely best effort.
11 LOG(INFO) << "Marking booted slot as good.";
12 // 如果updated_boot_flags_为false,调用boot_control_的MarkBootSuccessfulAsync方法
13 // 将当前启动分区标记为成功启动分区
14 if (!boot_control_->MarkBootSuccessfulAsync(
15 Bind(&UpdateAttempterAndroid::CompleteUpdateBootFlags,
16 base::Unretained(this)))) {
17 LOG(ERROR) << "Failed to mark current boot as successful.";
18 //调用CompleteUpdateBootFlags方法
19 CompleteUpdateBootFlags(false);
20 }
21}
22//更新标志位updated_boot_flags_，开始执行处理
23void UpdateAttempterAndroid::CompleteUpdateBootFlags(bool successful) {
24 updated_boot_flags_ = true;
25 ScheduleProcessingStart();
26}
27//开始执行处理
28void UpdateAttempterAndroid::ScheduleProcessingStart() {
29 LOG(INFO) << "Scheduling an action processor start.";
30 //执行StartProcessing()，开启action处理
31 brillo::MessageLoop::current()->PostTask(
32 FROM_HERE,
33 Bind([](ActionProcessor* processor) { processor->StartProcessing(); },
34 base::Unretained(processor_.get())));
35}
上面的最主要核心的部分已经说明完了，下面我们按继承的父类区分，分别介绍重写的方法
5、重写父类ServiceDelegateAndroidInterface的方法
1//暂停升级
2bool UpdateAttempterAndroid::SuspendUpdate(brillo::ErrorPtr* error) {
3 if (!ongoing_update_)
4 return LogAndSetError(error, FROM_HERE, "No ongoing update to suspend.");
5 //调用ActionProcessor的暂停处理方法
6 processor_->SuspendProcessing();
7 return true;
8}
9//继续升级
10bool UpdateAttempterAndroid::ResumeUpdate(brillo::ErrorPtr* error) {
11 if (!ongoing_update_)
12 return LogAndSetError(error, FROM_HERE, "No ongoing update to resume.");
13 //调用ActionProcessor的恢复处理方法
14 processor_->ResumeProcessing();
15 return true;
16}
17//取消升级
18bool UpdateAttempterAndroid::CancelUpdate(brillo::ErrorPtr* error) {
19 if (!ongoing_update_)
20 return LogAndSetError(error, FROM_HERE, "No ongoing update to cancel.");
21 调用ActionProcessor的停止处理方法
22 processor_->StopProcessing();
23 return true;
24}
25//重置状态，判断升级状态，重置为IDIE状态
26bool UpdateAttempterAndroid::ResetStatus(brillo::ErrorPtr* error) {
27 LOG(INFO) << "Attempting to reset state from "
28 << UpdateStatusToString(status_) << " to UpdateStatus::IDLE";
29 //根据status_的当前状态做相应的重置操作
30 switch (status_) {
31 //如果已经是IDIE状态，那么不用处理，直接return
32 case UpdateStatus::IDLE:
33 return true;
34 //如果是升级完成 需要重启的状态
35 case UpdateStatus::UPDATED_NEED_REBOOT: {
36 // Remove the reboot marker so that if the machine is rebooted
37 // after resetting to idle state, it doesn't go back to
38 // UpdateStatus::UPDATED_NEED_REBOOT state.
39 // 清除kPrefsUpdateCompletedOnBootId的标记
40 bool ret_value = prefs_->Delete(kPrefsUpdateCompletedOnBootId);
41 ClearMetricsPrefs();
42
43 // Update the boot flags so the current slot has higher priority.
44 //更新boot标记，将当前分区设置为正常启动分区
45 if (!boot_control_->SetActiveBootSlot(boot_control_->GetCurrentSlot()))
46 ret_value = false;
47
48 // Mark the current slot as successful again, since marking it as active
49 // may reset the successful bit. We ignore the result of whether marking
50 // the current slot as successful worked.
51 //再次通过异步操作，将当前分区标记为正常启动分区
52 if (!boot_control_->MarkBootSuccessfulAsync(Bind([](bool successful){})))
53 ret_value = false;
54
55 if (!ret_value) {
56 return LogAndSetError(
57 error,
58 FROM_HERE,
59 "Failed to reset the status to ");
60 }
61 //通知客户端重置成功，已经设置为了IDIE状态
62 SetStatusAndNotify(UpdateStatus::IDLE);
63 LOG(INFO) << "Reset status successful";
64 return true;
65 }
66 //如果是其他状态，不允许重置的操作，需要先取消正在进行的升级
67 default:
68 return LogAndSetError(
69 error,
70 FROM_HERE,
71 "Reset not allowed in this state. Cancel the ongoing update first");
72 }
73}
74
75bool UpdateAttempterAndroid::VerifyPayloadApplicable
76//TODO
可以看出这些方法其实就是调用了相应的ActionProcessor的对应方法进行处理
6、重写父类ActionProcessorDelegate的方法
1//该方法由ActionProcessor::StartNextActionOrFinish调用，执行子类重写的方法，
2//action队列为空的时候，那就是要么升级成功跑完了，要么报错了
3void UpdateAttempterAndroid::ProcessingDone(const ActionProcessor* processor,
4 ErrorCode code) {
5 LOG(INFO) << "Processing Done.";
6 //根据传入的errorcode 判断
7 switch (code) {
8 //如果是升级成功，写入升级成功的标记
9 case ErrorCode::kSuccess:
10 // Update succeeded.
11 WriteUpdateCompletedMarker();
12 prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
13
14 LOG(INFO) << "Update successfully applied, waiting to reboot.";
15 break;
16 //如果是升级失败了，那就重置升级
17 case ErrorCode::kFilesystemCopierError:
18 case ErrorCode::kNewRootfsVerificationError:
19 case ErrorCode::kNewKernelVerificationError:
20 case ErrorCode::kFilesystemVerifierError:
21 case ErrorCode::kDownloadStateInitializationError:
22 // Reset the ongoing update for these errors so it starts from the
23 // beginning next time.
24 DeltaPerformer::ResetUpdateProgress(prefs_, false);
25 LOG(INFO) << "Resetting update progress.";
26 break;
27 //如果是payload时间戳错误，写入错误并停止
28 case ErrorCode::kPayloadTimestampError:
29 // SafetyNet logging, b/36232423
30 android_errorWriteLog(0x534e4554, "36232423");
31 break;
32
33 default:
34 // Ignore all other error codes.
35 break;
36 }
37 //终止升级并进行通知
38 TerminateUpdateAndNotify(code);
39}
40
41//由ActionProcessor::StopProcessing调用
42void UpdateAttempterAndroid::ProcessingStopped(
43 const ActionProcessor* processor) {
44 //终止升级并进行通知，使用的errorcode为用户取消
45 TerminateUpdateAndNotify(ErrorCode::kUserCanceled);
46}
47
48//由ActionProcessor::ActionComplete调用
49void UpdateAttempterAndroid::ActionCompleted(ActionProcessor* processor,
50 AbstractAction* action,
51 ErrorCode code) {
52 // Reset download progress regardless of whether or not the download
53 // action succeeded.
54 //重置download_progress为0 不管是否升级成功了
55 const string type = action->Type();
56 if (type == DownloadAction::StaticType()) {
57 download_progress_ = 0;
58 }
59 if (type == PostinstallRunnerAction::StaticType()) {
60 bool succeeded =
61 code == ErrorCode::kSuccess || code == ErrorCode::kUpdatedButNotActive;
62 prefs_->SetBoolean(kPrefsPostInstallSucceeded, succeeded);
63 }
64 //如果不是成功状态，ActionProcessor会取消整个过程
65 if (code != ErrorCode::kSuccess) {
66 // If an action failed, the ActionProcessor will cancel the whole thing.
67 return;
68 }
69 //通知客户端升级状态
70 if (type == DownloadAction::StaticType()) {
71 SetStatusAndNotify(UpdateStatus::FINALIZING);
72 }
73}
这三个方法，是根据ActionProcessor的相关处理通知客户端和其他模块进行相应的状态更新
7、重写父类DownloadAction和PostinstallRunnerAction的方法
这部分我准备分析完action的时候再加上去，而且其实只有两个方法用到了，有两个是空方法
1void UpdateAttempterAndroid::BytesReceived(uint64_t bytes_progressed,
2 uint64_t bytes_received,
3 uint64_t total) {
4 double progress = 0;
5 if (total)
6 progress = static_cast<double>(bytes_received) / static_cast<double>(total);
7 if (status_ != UpdateStatus::DOWNLOADING || bytes_received == total) {
8 download_progress_ = progress;
9 SetStatusAndNotify(UpdateStatus::DOWNLOADING);
10 } else {
11 ProgressUpdate(progress);
12 }
13
14 // Update the bytes downloaded in prefs.
15 int64_t current_bytes_downloaded =
16 metrics_utils::GetPersistedValue(kPrefsCurrentBytesDownloaded, prefs_);
17 int64_t total_bytes_downloaded =
18 metrics_utils::GetPersistedValue(kPrefsTotalBytesDownloaded, prefs_);
19 prefs_->SetInt64(kPrefsCurrentBytesDownloaded,
20 current_bytes_downloaded + bytes_progressed);
21 prefs_->SetInt64(kPrefsTotalBytesDownloaded,
22 total_bytes_downloaded + bytes_progressed);
23}
24
25bool UpdateAttempterAndroid::ShouldCancel(ErrorCode* cancel_reason) {
26 // TODO(deymo): Notify the DownloadAction that it should cancel the update
27 // download.
28 return false;
29}
30
31void UpdateAttempterAndroid::DownloadComplete() {
32 // Nothing needs to be done when the download completes.
33}
34
35void UpdateAttempterAndroid::ProgressUpdate(double progress) {
36 // Self throttle based on progress. Also send notifications if progress is
37 // too slow.
38 if (progress == 1.0 ||
39 progress - download_progress_ >= kBroadcastThresholdProgress ||
40 TimeTicks::Now() - last_notify_time_ >=
41 TimeDelta::FromSeconds(kBroadcastThresholdSeconds)) {
42 download_progress_ = progress;
43 SetStatusAndNotify(status_);
44 }
45}
8、TerminateUpdateAndNotify方法
1//终止升级，并发送相关的通知
2void UpdateAttempterAndroid::TerminateUpdateAndNotify(ErrorCode error_code) {
3 //如果升级状态是空闲状态，那表明升级没进行，调用这个方法也没什么意义
4 if (status_ == UpdateStatus::IDLE) {
5 LOG(ERROR) << "No ongoing update, but TerminatedUpdate() called.";
6 return;
7 }
8 //设置下载进度为0
9 download_progress_ = 0;
10 //清空action队列
11 actions_.clear();
12 //根据升级的errorcode进行判断，如果成功，则使用状态UPDATED_NEED_REBOOT
13 UpdateStatus new_status =
14 (error_code == ErrorCode::kSuccess ? UpdateStatus::UPDATED_NEED_REBOOT
15 : UpdateStatus::IDLE);
16 //发送通知给到客户段，目前的升级进度
17 SetStatusAndNotify(new_status);
18 // 设定正在升级标志位为false
19 ongoing_update_ = false;
20
21 // The network id is only applicable to one download attempt and once it's
22 // done the network id should not be re-used anymore.
23 // 该网络ID仅适用于一次下载尝试，一旦完成，该网络ID将不能再次使用
24 if (!network_selector_->SetProcessNetwork(kDefaultNetworkId)) {
25 LOG(WARNING) << "Unable to unbind network.";
26 }
27 //发送给客户端升级的结果
28 for (auto observer : daemon_state_->service_observers())
29 observer->SendPayloadApplicationComplete(error_code);
30
31 CollectAndReportUpdateMetricsOnUpdateFinished(error_code);
32 ClearMetricsPrefs();
33 if (error_code == ErrorCode::kSuccess) {
34 metrics_utils::SetSystemUpdatedMarker(clock_.get(), prefs_);
35 // Clear the total bytes downloaded if and only if the update succeeds.
36 prefs_->SetInt64(kPrefsTotalBytesDownloaded, 0);
37 }
38}
好了到目前为止基本上这个文件里所有的流程我们大概跑了一遍，其中有一些我们其实没有分析到，prefs_和boot_control_的方法，不过并不影响我们的主要升级流程的分析，这两个都是设置了分区相关的标志位，下一篇开始分析各种action的，别问，问就是重点
3581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
