bool DaemonStateAndroid::Initialize() {

   boot_control_ = boot_control::CreateBootControl();                     //创建BootControl

   if (!boot_control_) {

     LOG(WARNING) << "Unable to create BootControl instance, using stub "

                  << "instead. All update attempts will fail.";

     boot_control_.reset(new BootControlStub());

   }

   hardware_ = hardware::CreateHardware();                               //创建hardware

   if (!hardware_) {

     LOG(ERROR) << "Error intializing the HardwareInterface.";

     return false;

   }

   LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode.";

   LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build.";

   // Initialize prefs.

   base::FilePath non_volatile_path;

   // TODO(deymo): Fall back to in-memory prefs if there's no physical directory

   // available.

   if (!hardware_->GetNonVolatileDirectory(&non_volatile_path)) {

     LOG(ERROR) << "Failed to get a non-volatile directory.";

     return false;

   }

   Prefs* prefs = new Prefs();                                       //创建Prefs

   prefs_.reset(prefs);

   if (!prefs->Init(non_volatile_path.Append(kPrefsSubDirectory))) {

     LOG(ERROR) << "Failed to initialize preferences.";

     return false;

   }

   // The CertificateChecker singleton is used by the update attempter.

   certificate_checker_.reset(

       new CertificateChecker(prefs_.get(), &openssl_wrapper_));     //设置certificateChecker

   certificate_checker_->Init();

   // Initialize the UpdateAttempter before the UpdateManager.

   update_attempter_.reset(new UpdateAttempterAndroid(              //设置UpdateAttempterAndroid

       this, prefs_.get(), boot_control_.get(), hardware_.get()));

   return true;

 }

 bool DaemonStateAndroid::StartUpdater() {

   // The DaemonState in Android is a passive daemon. It will only start applying

   // an update when instructed to do so from the exposed binder API.

   update_attempter_->Init();

   return true;

 }

 void UpdateAttempterAndroid::Init() {

   // In case of update_engine restart without a reboot we need to restore the

   // reboot needed state.

   if (UpdateCompletedOnThisBoot())

     SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);

   else

     SetStatusAndNotify(UpdateStatus::IDLE);

 }

  void UpdateAttempterAndroid::SetStatusAndNotify(UpdateStatus status) {

    status_ = status;

    size_t payload_size =

        install_plan_.payloads.empty() ?  : install_plan_.payloads[].size;

    for (auto observer : daemon_state_->service_observers()) {

      observer->SendStatusUpdate(

          , download_progress_, status_, "", payload_size);

    }

    last_notify_time_ = TimeTicks::Now();

 }

  Status BinderUpdateEngineAndroidService::bind(

      const android::sp<IUpdateEngineCallback>& callback, bool* return_value) {

    callbacks_.emplace_back(callback);

    const android::sp<IBinder>& callback_binder =

        IUpdateEngineCallback::asBinder(callback);

    auto binder_wrapper = android::BinderWrapper::Get();

    binder_wrapper->RegisterForDeathNotifications(

        callback_binder,

       base::Bind(

           base::IgnoreResult(&BinderUpdateEngineAndroidService::UnbindCallback),

           base::Unretained(this),

           base::Unretained(callback_binder.get())));

   // Send an status update on connection (except when no update sent so far),

   // since the status update is oneway and we don't need to wait for the

   // response.

   if (last_status_ != -)

     callback->onStatusUpdate(last_status_, last_progress_);

   *return_value = true;

   return Status::ok();

 }

 void BinderUpdateEngineAndroidService::SendStatusUpdate(

     int64_t /* last_checked_time */,

     double progress,

     update_engine::UpdateStatus status,

     const std::string& /* new_version  */,

     int64_t /* new_size */) {

   last_status_ = static_cast<int>(status);

   last_progress_ = progress;

   for (auto& callback : callbacks_) {

     callback->onStatusUpdate(last_status_, last_progress_);

   }

 }

 Status BinderUpdateEngineAndroidService::unbind(

     const android::sp<IUpdateEngineCallback>& callback, bool* return_value) {

   const android::sp<IBinder>& callback_binder =

       IUpdateEngineCallback::asBinder(callback);

   auto binder_wrapper = android::BinderWrapper::Get();

   binder_wrapper->UnregisterForDeathNotifications(callback_binder);

   *return_value = UnbindCallback(callback_binder.get());

   return Status::ok();

 }

 Status BinderUpdateEngineAndroidService::applyPayload(

     const android::String16& url,

     int64_t payload_offset,

     int64_t payload_size,

     const std::vector<android::String16>& header_kv_pairs) {

   const std::string payload_url{android::String8{url}.string()};

   std::vector<std::string> str_headers;

   str_headers.reserve(header_kv_pairs.size());

   for (const auto& header : header_kv_pairs) {

     str_headers.emplace_back(android::String8{header}.string());

   }

   brillo::ErrorPtr error;

   if (!service_delegate_->ApplyPayload(

           payload_url, payload_offset, payload_size, str_headers, &error)) {

     return ErrorPtrToStatus(error);

   }

   return Status::ok();

 }

   bool UpdateAttempterAndroid::ApplyPayload(

       const string& payload_url,

       int64_t payload_offset,

       int64_t payload_size,

       const vector<string>& key_value_pair_headers,

       brillo::ErrorPtr* error) {

     if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {          //检查是否已经更新完成，需要重新启动

       return LogAndSetError(

           error, FROM_HERE, "An update already applied, waiting for reboot");

    }

    if (ongoing_update_) {                                       //检查是否正在更新

      return LogAndSetError(

          error, FROM_HERE, "Already processing an update, cancel it first.");

    }

    DCHECK(status_ == UpdateStatus::IDLE);                       //检查当前是否为空闲状态

    std::map<string, string> headers;

    for (const string& key_value_pair : key_value_pair_headers) {

      string key;

      string value;

      if (!brillo::string_utils::SplitAtFirst(

              key_value_pair, "=", &key, &value, false)) {

        return LogAndSetError(

            error, FROM_HERE, "Passed invalid header: " + key_value_pair);

      }

      if (!headers.emplace(key, value).second)

        return LogAndSetError(error, FROM_HERE, "Passed repeated key: " + key);      //将传递进来的key-value保存到headers中

    }

    // Unique identifier for the payload. An empty string means that the payload

    // can't be resumed.

    string payload_id = (headers[kPayloadPropertyFileHash] +

                         headers[kPayloadPropertyMetadataHash]);                     //根据Payload的hash和元数据的hash计算一个payload_id

    // Setup the InstallPlan based on the request.

    install_plan_ = InstallPlan();                                                   //创建一个InstallPlan

    install_plan_.download_url = payload_url;

    install_plan_.version = "";

    base_offset_ = payload_offset;

    InstallPlan::Payload payload;

    payload.size = payload_size;

    if (!payload.size) {

      if (!base::StringToUint64(headers[kPayloadPropertyFileSize],

                                &payload.size)) {

        payload.size = ;

      }

    }

    if (!brillo::data_encoding::Base64Decode(headers[kPayloadPropertyFileHash],

                                             &payload.hash)) {

      LOG(WARNING) << "Unable to decode base64 file hash: "

                   << headers[kPayloadPropertyFileHash];

    }

    if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],

                              &payload.metadata_size)) {

      payload.metadata_size = ;

    }

    // The |payload.type| is not used anymore since minor_version 3.

    payload.type = InstallPayloadType::kUnknown;

    install_plan_.payloads.push_back(payload);                          //为payload赋值完成后，将其放入到集合中，因为ApplyPayload可能被多次调用，会有多个payload

    // The |public_key_rsa| key would override the public key stored on disk.

    install_plan_.public_key_rsa = "";

    install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild();  //是否进行强制性的hash验证，如果为user版则为true,如果为userdebug则为false

    install_plan_.is_resume = !payload_id.empty() &&

                              DeltaPerformer::CanResumeUpdate(prefs_, payload_id);  //是否接着上次未更新完的继续更新

    if (!install_plan_.is_resume) {                                                 //如果从头开始更新

      if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) {                    //重置更新进度

        LOG(WARNING) << "Unable to reset the update progress.";

      }

      if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) {           //保存payload_id

        LOG(WARNING) << "Unable to save the update check response hash.";

      }

    }

    install_plan_.source_slot = boot_control_->GetCurrentSlot();                //当前正在运行的slot

    install_plan_.target_slot = install_plan_.source_slot ==  ?  : ;         //备用的也就是将要升级的slot

    int data_wipe = ;                                                          //是否进行数据擦除，也就是恢复出厂设置，在做升级包时可以指定该值 -w

    install_plan_.powerwash_required =

        base::StringToInt(headers[kPayloadPropertyPowerwash], &data_wipe) &&

        data_wipe != ;

    NetworkId network_id = kDefaultNetworkId;                                     //NetworkId没有使用过，估计和流式更新相关。

    if (!headers[kPayloadPropertyNetworkId].empty()) {

      if (!base::StringToUint64(headers[kPayloadPropertyNetworkId],

                                &network_id)) {

        return LogAndSetError(

            error,

            FROM_HERE,

            "Invalid network_id: " + headers[kPayloadPropertyNetworkId]);

      }

      if (!network_selector_->SetProcessNetwork(network_id)) {

        return LogAndSetError(

            error,

            FROM_HERE,

            "Unable to set network_id: " + headers[kPayloadPropertyNetworkId]);

      }

    }

   LOG(INFO) << "Using this install plan:";

   install_plan_.Dump();

   BuildUpdateActions(payload_url);        //创建Action,这一架构可以说是更新的主要架构

   // Setup extra headers.

   HttpFetcher* fetcher = download_action_->http_fetcher();

   if (!headers[kPayloadPropertyAuthorization].empty())

     fetcher->SetHeader("Authorization", headers[kPayloadPropertyAuthorization]);

   if (!headers[kPayloadPropertyUserAgent].empty())

     fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);

   SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);

   ongoing_update_ = true;                 //表式正在更新

   // Just in case we didn't update boot flags yet, make sure they're updated

   // before any update processing starts. This will start the update process.

   UpdateBootFlags();                      //修改bootFlags并且开始执行Action

   return true;

 }

 FILE_HASH=4kYpprUJyMwW8NNV25v0ovMWV11PPijNANQwHy0oZwc=

 FILE_SIZE=

 METADATA_HASH=l2ih2Xam7jqAQYhr9SRdVddG9NPeenaWzTEd+DHct+o=

 METADATA_SIZE=

   namespace chromeos_update_engine {

   enum class InstallPayloadType {    //升级包的类型

     kUnknown,                         //未知

     kFull,                             //全包

     kDelta,                            //差分包

   };

   std::string InstallPayloadTypeToString(InstallPayloadType type);

  struct InstallPlan {

    InstallPlan() = default;

    bool operator==(const InstallPlan& that) const;

    bool operator!=(const InstallPlan& that) const;

    void Dump() const;

    // Load the |source_path| and |target_path| of all |partitions| based on the

    // |source_slot| and |target_slot| if available. Returns whether it succeeded

    // to load all the partitions for the valid slots.

    bool LoadPartitionsFromSlots(BootControlInterface* boot_control);      //获取source_slot和target_slot中的分区path

    bool is_resume{false};                                                 // 是否未更新完成需要恢复更新

    std::string download_url;  // url to download from                      升级文件的url

    std::string version;       // version we are installing.                版本号

    struct Payload {

      uint64_t size = ;               // size of the payload              payload.bin的大小

      uint64_t metadata_size = ;      // size of the metadata             元数据的大小

      std::string metadata_signature;  // signature of the metadata in base64   元数据的签名

      brillo::Blob hash;               // SHA256 hash of the payload        payload.bin的hash

      InstallPayloadType type{InstallPayloadType::kUnknown};                //升级包的类型

      // Only download manifest and fill in partitions in install plan without

      // apply the payload if true. Will be set by DownloadAction when resuming

      // multi-payload.

      bool already_applied = false;                                        //升级包是否已经被应用

      bool operator==(const Payload& that) const {

        return size == that.size && metadata_size == that.metadata_size &&

               metadata_signature == that.metadata_signature &&

               hash == that.hash && type == that.type &&

               already_applied == that.already_applied;

      }

    };

    std::vector<Payload> payloads;

    // The partition slots used for the update.

    BootControlInterface::Slot source_slot{BootControlInterface::kInvalidSlot};  //定义source_slot

    BootControlInterface::Slot target_slot{BootControlInterface::kInvalidSlot};  //定义target_slot

    // The vector below is used for partition verification. The flow is:

    //

    // 1. DownloadAction fills in the expected source and target partition sizes

    // and hashes based on the manifest.

    //

    // 2. FilesystemVerifierAction computes and verifies the partition sizes and

    // hashes against the expected values.

    struct Partition {                                              //一个分区在source_slot和target_slot都存在

      bool operator==(const Partition& that) const;

      // The name of the partition.

      std::string name;

      std::string source_path;                                 //在source_slot中的位置

      uint64_t source_size{};                                 //大小

      brillo::Blob source_hash;                                //hash

      std::string target_path;                                  //在target_slot中的位置

      uint64_t target_size{};

      brillo::Blob target_hash;                                

      // Whether we should run the postinstall script from this partition and the

      // postinstall parameters.

      bool run_postinstall{false};

      std::string postinstall_path;

      std::string filesystem_type;                               //文件系统的类型

      bool postinstall_optional{false};

    };

    std::vector<Partition> partitions;

    // True if payload hash checks are mandatory based on the system state and

    // the Omaha response.

    bool hash_checks_mandatory{false};                        //是否强制进行hash检查

    // True if Powerwash is required on reboot after applying the payload.

    // False otherwise.

    bool powerwash_required{false};                           //是否在升级时进行数据的擦除

    // If not blank, a base-64 encoded representation of the PEM-encoded

    // public key in the response.

    std::string public_key_rsa;                             //public_key 一般为null,这个秘钥常常是已经被内置到了系统中了

  };

  }