Android系统Recovery工作原理3-- 升级包的制作


 ㈡ 下面我们分析ota_from_target_files这个python脚本是怎样生成最终zip包的。先讲这个脚本的代码贴出来如下:

import sys      if sys.hexversion 0x02040000:     PRint >> sys.stderr, "Python 2.4 or newer is required."     sys.exit(1)      import copy   import errno   import os   import re   import sha   import subprocess   import tempfile   import time   import zipfile      import common   import edify_generator      OPTIONS common.OPTIONS   OPTIONS.package_key "build/target/product/security/testkey"   OPTIONS.incremental_source None   OPTIONS.require_verbatim set()   OPTIONS.prohibit_verbatim set(("system/build.prop",))   OPTIONS.patch_threshold 0.95   OPTIONS.wipe_user_data False   OPTIONS.omit_prereq False   OPTIONS.extra_script None   OPTIONS.worker_threads      def MostPopularKey(d, default):     """Given dict, return the key corresponding to the largest    value.  Returns 'default' if the dict is empty."""     [(v, k) for (k, v) in d.iteritems()]     if not x: return default     x.sort()     return x[-1][1]         def IsSymlink(info):     """Return true if the zipfile.ZipInfo object passed in represents    symlink."""     return (info.external_attr >> 16) == 0120777         class Item:     """Items represent the metadata (user, group, mode) of files and    directories in the system image."""     ITEMS {}     def __init__(self, name, dir=False): name       self.uid None       self.gid None       self.mode None       self.dir dir          if name:         self.parent Item.Get(os.path.dirname(name), dir=True)         self.parent.children.append(self)       else:         self.parent None       if dir:         self.children []        def Dump(self, indent=0):       if self.uid is not None:         print "%s%s %d %d %o" ("  "*indent,, self.uid, self.gid, self.mode)       else:         print "%s%s %s %s %s" ("  "*indent,, self.uid, self.gid, self.mode)       if self.dir:         print "%s%s" ("  "*indent, self.descendants)         print "%s%s" ("  "*indent, self.best_subtree)         for in self.children:           i.Dump(indent=indent+1)       @classmethod     def Get(cls, name, dir=False):       if name not in cls.ITEMS:         cls.ITEMS[name] Item(name, dir=dir)       return cls.ITEMS[name]       @classmethod     def GetMetadata(cls, input_zip):          try:         See if the target_files contains record of what the uid,         gid, and mode is supposed to be.         output"META/filesystem_config.txt")       except KeyError:         Run the external 'fs_config' program to determine the desired         uid, gid, and mode for every Item object.  Note this uses the         one in the client now, which might not be the same as the one         used when this target_files was built.         common.Run(["fs_config"], stdin=subprocess.PIPE,                        stdout=subprocess.PIPE, stderr=subprocess.PIPE)         suffix False: "", True: "/"         input "".join(["%s%s\n" (, suffix[i.dir])                          for in cls.ITEMS.itervalues() if])         output, error p.communicate(input)         assert not error          for line in output.split("\n"):         if not line: continue         name, uid, gid, mode line.split()         cls.ITEMS.get(name, None)         if is not None:           i.uid int(uid)           i.gid int(gid)           i.mode int(mode, 8)           if i.dir:             i.children.sort(key=lambda i:          set metadata for the files generated by this script.       cls.ITEMS.get("system/recovery-from-boot.p", None)       if i: i.uid, i.gid, i.mode 0, 0, 0644       cls.ITEMS.get("system/etc/", None)       if i: i.uid, i.gid, i.mode 0, 0, 0544        def CountChildMetadata(self):       """Count up the (uid, gid, mode) tuples for all children and      determine the best strategy for using set_perm_recursive and      set_perm to correctly chown/chmod all the files to their desired      values.  Recursively calls itself for all descendants.        Returns dict of {(uid, gid, dmode, fmode): count} counting up      all descendants of this node.  (dmode or fmode may be None.)  Also      sets the best_subtree of each directory Item to the (uid, gid,      dmode, fmode) tuple that will match the most descendants of that      Item.      """          assert self.dir       self.descendants {(self.uid, self.gid, self.mode, None): 1}       for in self.children:         if i.dir:           for k, in i.CountChildMetadata().iteritems():             d[k] d.get(k, 0)         else:           (i.uid, i.gid, None, i.mode)           d[k] d.get(k, 0)          Find the (uid, gid, dmode, fmode) tuple that matches the most       descendants.          First, find the (uid, gid) pair that matches the most       descendants.       ug {}       for (uid, gid, _, _), count in d.iteritems():         ug[(uid, gid)] ug.get((uid, gid), 0) count       ug MostPopularKey(ug, (0, 0))          Now find the dmode and fmode that match the most descendants       with that (uid, gid), and choose those.       best_dmode (0, 0755)       best_fmode (0, 0644)       for k, count in d.iteritems():         if k[:2] != ug: continue         if k[2] is not None and count >= best_dmode[0]: best_dmode (count, k[2])         if k[3] is not None and count >= best_fmode[0]: best_fmode (count, k[3])       self.best_subtree ug (best_dmode[1], best_fmode[1])          return        def SetPermissions(self, script):       """Append set_perm/set_perm_recursive commands to 'script' to      set all permissions, users, and groups for the tree of files      rooted at 'self'."""          self.CountChildMetadata()          def recurse(item, current):         current is the (uid, gid, dmode, fmode) tuple that the current         item (and all its children) have already been set to.  We only         need to issue set_perm/set_perm_recursive commands if we're         supposed to be something different.         if item.dir:           if current != item.best_subtree:             script.SetPermissionsRecursive("/", *item.best_subtree)             current item.best_subtree              if item.uid != current[0] or item.gid != current[1] or              item.mode != current[2]:             script.SetPermissions("/", item.uid, item.gid, item.mode)              for in item.children:             recurse(i, current)         else:           if item.uid != current[0] or item.gid != current[1] or                  item.mode != current[3]:             script.SetPermissions("/", item.uid, item.gid, item.mode)          recurse(self, (-1, -1, -1, -1))         def CopySystemFiles(input_zip, output_zip=None,                       substitute=None):     """Copies files underneath system/ in the input zip to the output    zip.  Populates the Item class with their metadata, and returns    list of symlinks.  output_zip may be None, in which case the copy is    skipped (but the other side effects still happen).  substitute is an    optional dict of {output filename: contents} to be output instead of    certain input files.    """        symlinks []        for info in input_zip.infolist():       if info.filename.startswith("SYSTEM/"):         basefilename info.filename[7:]         if IsSymlink(info):           symlinks.append((,                            "/system/" basefilename))         else:           info2 copy.copy(info)           fn info2.filename "system/" basefilename           if substitute and fn in substitute and substitute[fn] is None:             continue           if output_zip is not None:             if substitute and fn in substitute:               data substitute[fn]             else:               data             output_zip.writestr(info2, data)           if fn.endswith("/"):             Item.Get(fn[:-1], dir=True)           else:             Item.Get(fn, dir=False)        symlinks.sort()     return symlinks         def SignOutput(temp_zip_name, output_zip_name):     key_passWordcommon.GetKeyPasswords([OPTIONS.package_key])     pw key_passwords[OPTIONS.package_key]        common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw,                     whole_file=True)         def AppendAssertions(script, input_zip):     device GetBuildProp("ro.product.device", input_zip)     script.AssertDevice(device)         def MakeRecoveryPatch(output_zip, recovery_img, boot_img):     """Generate binary patch that creates the recovery image starting    with the boot image.  (Most of the space in these images is just the    kernel, which is identical for the two, so the resulting patch    should be efficient.)  Add it to the output zip, along with shell    script that is run from init.rc on first boot to actually do the    patching and install the new recovery image.      recovery_img and boot_img should be File objects for the    corresponding images.      Returns an Item for the shell script, which must be made    executable.    """        common.Difference(recovery_img, boot_img)     _, _, patch d.ComputePatch()     common.ZipWriteStr(output_zip, "recovery/recovery-from-boot.p", patch)     Item.Get("system/recovery-from-boot.p", dir=False)        boot_type, boot_device common.GetTypeAndDevice("/boot", OPTIONS.info_dict)     recovery_type, recovery_device common.GetTypeAndDevice("/recovery", OPTIONS.info_dict)        Images with different content will have different first page, so     we check to see if this recovery has already been installed by     testing just the first 2k.     HEADER_SIZE 2048     header_sha1 sha.sha([:HEADER_SIZE]).hexdigest()     sh """#!/system/bin/sh  if applypatch -c %(recovery_type)s:%(recovery_device)s:%(header_size)d:%(header_sha1)s; then    log -t recovery "Installing new recovery image"    applypatch %(boot_type)s:%(boot_device)s:%(boot_size)d:%(boot_sha1)s %(recovery_type)s:%(recovery_device)s %(recovery_sha1)s %(recovery_size)d %(boot_sha1)s:/system/recovery-from-boot.p  else    log -t recovery "Recovery image already installed"  fi  """ 'boot_size': boot_img.size,           'boot_sha1': boot_img.sha1,           'header_size': HEADER_SIZE,           'header_sha1': header_sha1,           'recovery_size': recovery_img.size,           'recovery_sha1': recovery_img.sha1,           'boot_type': boot_type,           'boot_device': boot_device,           'recovery_type': recovery_type,           'recovery_device': recovery_device,               common.ZipWriteStr(output_zip, "recovery/etc/", sh)     return Item.Get("system/etc/", dir=False)         def WriteFullOTAPackage(input_zip, output_zip):     TODO: how to determine this?  We don't know what version it will     be installed on top of.  For now, we expect the API just won't     change very often.     script edify_generator.EdifyGenerator(3, OPTIONS.info_dict)        metadata {"post-build": GetBuildProp("", input_zip),                 "pre-device": GetBuildProp("ro.product.device", input_zip),                 "post-timestamp": GetBuildProp("", input_zip),                        device_specific common.DeviceSpecificParams(         input_zip=input_zip,         input_version=OPTIONS.info_dict["recovery_api_version"],         output_zip=output_zip,         script=script,         input_tmp=OPTIONS.input_tmp,         metadata=metadata,         info_dict=OPTIONS.info_dict)        if not OPTIONS.omit_prereq:       ts GetBuildProp("", input_zip)       script.AssertOlderBuild(ts)        AppendAssertions(script, input_zip)     device_specific.FullOTA_Assertions()        script.ShowProgress(0.5, 0)        if OPTIONS.wipe_user_data:       script.FormatPartition("/data")        script.FormatPartition("/system")     script.Mount("/system")     script.UnpackPackageDir("recovery", "/system")     script.UnpackPackageDir("system", "/system")        symlinks CopySystemFiles(input_zip, output_zip)     script.MakeSymlinks(symlinks)        boot_img common.File("boot.img", common.BuildBootableImage(         os.path.join(OPTIONS.input_tmp, "BOOT")))     recovery_img common.File("recovery.img", common.BuildBootableImage(         os.path.join(OPTIONS.input_tmp, "RECOVERY")))     MakeRecoveryPatch(output_zip, recovery_img, boot_img)        Item.GetMetadata(input_zip)     Item.Get("system").SetPermissions(script)        common.CheckSize(, "boot.img", OPTIONS.info_dict)     common.ZipWriteStr(output_zip, "boot.img",     script.ShowProgress(0.2, 0)        script.ShowProgress(0.2, 10)     script.WriteRawImage("/boot", "boot.img")        script.ShowProgress(0.1, 0)     device_specific.FullOTA_InstallEnd()        if OPTIONS.extra_script is not None:       script.AppendExtra(OPTIONS.extra_script)        script.UnmountAll()     script.AddToZip(input_zip, output_zip)     WriteMetadata(metadata, output_zip)         def WriteMetadata(metadata, output_zip):     common.ZipWriteStr(output_zip, "META-INF/com/android/metadata",                        "".join(["%s=%s\n" kv                                 for kv in sorted(metadata.iteritems())]))               def LoadSystemFiles(z):     """Load all the files from SYSTEM/... in given target-files    ZipFile, and return dict of {filename: File object}."""     out {}     for info in z.infolist():       if info.filename.startswith("SYSTEM/") and not IsSymlink(info):         fn "system/" info.filename[7:]         data         out[fn] common.File(fn, data)     return out         def GetBuildProp(property, z):     """Return the fingerprint of the build of given target-files    ZipFile object."""     bp"SYSTEM/build.prop")     if not property:       return bp r"=(.*)\n", bp)     if not m:       raise common.ExternalError("couldn't find %s in build.prop" (property,))     return         def WriteIncrementalOTAPackage(target_zip, source_zip, output_zip):     source_version OPTIONS.source_info_dict["recovery_api_version"]     target_version OPTIONS.target_info_dict["recovery_api_version"]        if source_version == 0:       print ("WARNING: generating edify script for source that              "can't install it.")     script edify_generator.EdifyGenerator(source_version, OPTIONS.info_dict)        metadata {"pre-device": GetBuildProp("ro.product.device", source_zip),                 "post-timestamp": GetBuildProp("", target_zip),                        device_specific common.DeviceSpecificParams(         source_zip=source_zip,         source_version=source_version,         target_zip=target_zip,         target_version=target_version,         output_zip=output_zip,         script=script,         metadata=metadata,         info_dict=OPTIONS.info_dict)        print "Loading target..."     target_data LoadSystemFiles(target_zip)     print "Loading source..."     source_data LoadSystemFiles(source_zip)        verbatim_targets []     patch_list []     diffs []     largest_source_size     for fn in sorted(target_data.keys()):       tf target_data[fn]       assert fn ==       sf source_data.get(fn, None)          if sf is None or fn in OPTIONS.require_verbatim:         This file should be included verbatim         if fn in OPTIONS.prohibit_verbatim:           raise common.ExternalError(""%s" must be sent verbatim" (fn,))         print "send", fn, "verbatim"         tf.AddToZip(output_zip)         verbatim_targets.append((fn, tf.size))       elif tf.sha1 != sf.sha1:         File is different; consider sending as patch         diffs.append(common.Difference(tf, sf))       else:         Target file identical to source.         pass        common.ComputeDifferences(diffs)        for diff in diffs:       tf, sf, diff.GetPatch()       if is None or len(d) tf.size OPTIONS.patch_threshold:         patch is almost as big as the file; don't bother patching         tf.AddToZip(output_zip)         verbatim_targets.append((, tf.size))       else:         common.ZipWriteStr(output_zip, "patch/" ".p", d)         patch_list.append((, tf, sf, tf.size, sha.sha(d).hexdigest()))         largest_source_size max(largest_source_size, sf.size)        source_fp GetBuildProp("", source_zip)     target_fp GetBuildProp("", target_zip)     metadata["pre-build"] source_fp     metadata["post-build"] target_fp        script.Mount("/system")     script.AssertSomeFingerprint(source_fp, target_fp)        source_boot common.File("/tmp/boot.img",                               common.BuildBootableImage(                                   os.path.join(OPTIONS.source_tmp, "BOOT")))     target_boot common.File("/tmp/boot.img",                               common.BuildBootableImage(                                   os.path.join(OPTIONS.target_tmp, "BOOT")))     updating_boot ( !=        source_recovery common.File("system/recovery.img",                                   common.BuildBootableImage(                                       os.path.join(OPTIONS.source_tmp, "RECOVERY")))     target_recovery common.File("system/recovery.img",                                   common.BuildBootableImage(                                       os.path.join(OPTIONS.target_tmp, "RECOVERY")))     updating_recovery ( !=        Here's how we divide up the progress bar:      0.1 for verifying the start state (PatchCheck calls)      0.8 for applying patches (ApplyPatch calls)      0.1 for unpacking verbatim files, symlinking, and doing the          device-specific commands.        AppendAssertions(script, target_zip)     device_specific.IncrementalOTA_Assertions()        script.Print("Verifying current system...")        script.ShowProgress(0.1, 0)     total_verify_size float(sum([i[2].size for in patch_list]) 1)     if updating_boot:       total_verify_size += source_boot.size     so_far        for fn, tf, sf, size, patch_sha in patch_list:       script.PatchCheck("/"+fn, tf.sha1, sf.sha1)       so_far += sf.size       script.SetProgress(so_far total_verify_size)        if updating_boot:       common.Difference(target_boot, source_boot)       _, _, d.ComputePatch()       print "boot      target: %d  source: %d  diff: %d"           target_boot.size, source_boot.size, len(d))          common.ZipWriteStr(output_zip, "patch/boot.img.p", d)          boot_type, boot_device common.GetTypeAndDevice("/boot", OPTIONS.info_dict)          script.PatchCheck("%s:%s:%d:%s:%d:%s"                         (boot_type, boot_device,                          source_boot.size, source_boot.sha1,                          target_boot.size, target_boot.sha1))       so_far += source_boot.size       script.SetProgress(so_far total_verify_size)        if patch_list or updating_recovery or updating_boot:       script.CacheFreeSpaceCheck(largest_source_size)        device_specific.IncrementalOTA_VerifyEnd()        script.Comment("---- start making changes here ----")        if OPTIONS.wipe_user_data:       script.Print("Erasing user data...")       script.FormatPartition("/data")        script.Print("Removing unneeded files...")     script.DeleteFiles(["/"+i[0] for in verbatim_targets]                        ["/"+i for in sorted(source_data)                               if not in target_data]                        ["/system/recovery.img"])        script.ShowProgress(0.8, 0)     total_patch_size float(sum([i[1].size for in patch_list]) 1)     if updating_boot:       total_patch_size += target_boot.size     so_far        script.Print("Patching system files...")     for fn, tf, sf, size, in patch_list:       script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p")       so_far += tf.size       script.SetProgress(so_far total_patch_size)        if updating_boot:       Produce the boot image by applying patch to the current       contents of the boot partition, and write it back to the       partition.       script.Print("Patching boot image...")       script.ApplyPatch("%s:%s:%d:%s:%d:%s"                         (boot_type, boot_device,                            source_boot.size, source_boot.sha1,                            target_boot.size, target_boot.sha1),                         "-",                         target_boot.size, target_boot.sha1,                         source_boot.sha1, "patch/boot.img.p")       so_far += target_boot.size       script.SetProgress(so_far total_patch_size)       print "boot image changed; including."     else:       print "boot image unchanged; skipping."        if updating_recovery:       Is it better to generate recovery as patch from the current       boot image, or from the previous recovery image?  For large       updates with significant kernel changes, probably the former.       For small updates where the kernel hasn't changed, almost       certainly the latter.  We pick the first option.  Future       complicated schemes may let us effectively use both.             wacky possibility: as long as there is room in the boot       partition, include the binaries and image files from recovery in       the boot image (though not in the ramdisk) so they can be used       as fodder for constructing the recovery image.       MakeRecoveryPatch(output_zip, target_recovery, target_boot)       script.DeleteFiles(["/system/recovery-from-boot.p",                           "/system/etc/"])       print "recovery image changed; including as patch from boot."     else:       print "recovery image unchanged; skipping."        script.ShowProgress(0.1, 10)        target_symlinks CopySystemFiles(target_zip, None)        target_symlinks_d dict([(i[1], i[0]) for in target_symlinks])     temp_script script.MakeTemporary()     Item.GetMetadata(target_zip)     Item.Get("system").SetPermissions(temp_script)        Note that this call will mess up the tree of Items, so make sure     we're done with it.     source_symlinks CopySystemFiles(source_zip, None)     source_symlinks_d dict([(i[1], i[0]) for in source_symlinks])        Delete all the symlinks in source that aren't in target.  This     needs to happen before verbatim files are unpacked, in case     symlink in the source is replaced by real file in the target.     to_delete []     for dest, link in source_symlinks:       if link not in target_symlinks_d:         to_delete.append(link)     script.DeleteFiles(to_delete)        if verbatim_targets:       script.Print("Unpacking new files...")       script.UnpackPackageDir("system", "/system")        if updating_recovery:       script.Print("Unpacking new recovery...")       script.UnpackPackageDir("recovery", "/system")        script.Print("Symlinks and permissions...")        Create all the symlinks that don't already exist, or point to     somewhere different than what we want.  Delete each symlink before     creating it, since the 'symlink' command won't overwrite.     to_create []     for dest, link in target_symlinks:       if link in source_symlinks_d:         if dest != source_symlinks_d[link]:           to_create.append((dest, link))       else:         to_create.append((dest, link))     script.DeleteFiles([i[1] for in to_create])     script.MakeSymlinks(to_create)        Now that the symlinks are created, we can set all the     permissions.     script.AppendScript(temp_script)        Do device-specific installation (eg, write radio image).     device_specific.IncrementalOTA_InstallEnd()        if OPTIONS.extra_script is not None:       scirpt.AppendExtra(OPTIONS.extra_script)        script.AddToZip(target_zip, output_zip)     WriteMetadata(metadata, output_zip)         def main(argv):        def option_handler(o, a):       if in ("-b", "--board_config"):         pass   deprecated       elif in ("-k", "--package_key"):         OPTIONS.package_key       elif in ("-i", "--incremental_from"):         OPTIONS.incremental_source       elif in ("-w", "--wipe_user_data"):         OPTIONS.wipe_user_data True       elif in ("-n", "--no_prereq"):         OPTIONS.omit_prereq True       elif in ("-e", "--extra_script"):         OPTIONS.extra_script       elif in ("--worker_threads"):         OPTIONS.worker_threads int(a)       else:         return False       return True        args common.ParSEOptions(argv, __doc__,                                extra_opts="b:k:i:d:wne:",                                extra_long_opts=["board_config=",                                                 "package_key=",                                                 "incremental_from=",                                                 "wipe_user_data",                                                 "no_prereq",                                                 "extra_script=",                                                 "worker_threads="],                                extra_option_handler=option_handler)        if len(args) != 2:       common.Usage(__doc__)       sys.exit(1)        if OPTIONS.extra_script is not None:       OPTIONS.extra_script open(OPTIONS.extra_script).read()        print "unzipping target target-files..."     OPTIONS.input_tmp common.UnzipTemp(args[0])        OPTIONS.target_tmp OPTIONS.input_tmp     input_zip zipfile.ZipFile(args[0], "r")     OPTIONS.info_dict common.LoadInfoDict(input_zip)     if OPTIONS.verbose:       print "--- target info ---"       common.DumpInfoDict(OPTIONS.info_dict)        if OPTIONS.device_specific is None:       OPTIONS.device_specific OPTIONS.info_dict.get("tool_extensions", None)     if OPTIONS.device_specific is not None:       OPTIONS.device_specific os.path.normpath(OPTIONS.device_specific)       print "using device-specific extensions in", OPTIONS.device_specific        if OPTIONS.package_key:       temp_zip_file tempfile.NamedTemporaryFile()       output_zip zipfile.ZipFile(temp_zip_file, "w",                                    compression=zipfile.ZIP_DEFLATED)     else:       output_zip zipfile.ZipFile(args[1], "w",                                    compression=zipfile.ZIP_DEFLATED)        if OPTIONS.incremental_source is None:       WriteFullOTAPackage(input_zip, output_zip)     else:       print "unzipping source target-files..."       OPTIONS.source_tmp common.UnzipTemp(OPTIONS.incremental_source)       source_zip zipfile.ZipFile(OPTIONS.incremental_source, "r")       OPTIONS.target_info_dict OPTIONS.info_dict       OPTIONS.source_info_dict common.LoadInfoDict(source_zip)       if OPTIONS.verbose:         print "--- source info ---"         common.DumpInfoDict(OPTIONS.source_info_dict)       WriteIncrementalOTAPackage(input_zip, source_zip, output_zip)        output_zip.close()     if OPTIONS.package_key:       SignOutput(, args[1])       temp_zip_file.close()        common.Cleanup()        print "done."         if __name__ == '__main__':     try:       common.CloseInheritedPipes()       main(sys.argv[1:])     except common.ExternalError, e:       print       print   ERROR: %s" (e,)       print       sys.exit(1)  


                       ① 在main函数的开头,首先将用户设定的option选项存入OPTIONS变量中,它是一个python中的类。紧接着判断有没有额外的脚本,如果有就读入到OPTIONS变量中。                        ② 解压缩输入的zip包,即我们在上文生成的原始zip包。然后判断是否用到device-specific extensions(设备扩展)如果用到,随即读入到OPTIONS变量中。                        ③ 判断是否签名,然后判断是否有新内容的增量源,有的话就解压该增量源包放入一个临时变量中(source_zip)。自此,所有的准备工作已完毕,随即会调用该 脚本中最主要的函数WriteFullOTAPackage(input_zip,output_zip)                        ④ WriteFullOTAPackage函数的处理过程是先获得脚本的生成器。默认格式是edify。然后获得metadata元数据,此数据来至于Android的一些环境变量。然后获得设备配置参数比如api函数的版本。然后判断是否忽略时间戳。                        ⑤ WriteFullOTAPackage函数做完准备工作后就开始生成升级用的脚本文件(updater-script)了。生成脚本文件后将上一步获得的metadata元数据写入到输出包out_zip。                        ⑥至此一个完整的update.zip升级包就生成了。生成位置在:out/target/product/tcc8800 /。将升级包拷贝到SD卡中就可以用来升级了。

四、 Android OTA增量包update.zip的生成



          ① 在源码根目录下依次执行下列命令            $ . build/            $ lunch 选择17            $ make            $ make otapackage            执行上面的命令后会在out/target/product/tcc8800/下生成我们第一个系统升级包。我们先将其命名为           ② 在源码中修改我们需要改变的部分,比如修改内核配置,增加新的驱动等等。修改后再一次执行上面的命令。就会生成第二个我们修改后生成的update.zip升级包。将  其命名为。

          ③ 在上文中我们看了ota_from_target_files.py脚本的使用帮助,其中选项-i就是用来生成差分增量包的。使用方法是以上面的 和B.zip包作为输入,以update.zip包作  为输出。生成的update.zip就是我们最后需要的增量包。


              $ ./build/tools/releasetools/ota_from_target_files -i。

              在执行上述命令时会出现未找到recovery_api_version的错误。原因是在执行上面的脚本时如果使用选项i则会调用 WriteIncrementalOTAPackage会从A包和B包中的META目录下搜索misc_info.txt来读取 recovery_api_version的值。但是在执行make  otapackage命令时生成的update.zip包中没有这个目录更没有这个文档。

              此时我们就需要使用执行make otapackage生成的原始的zip包。这个包的位置在out/target/product/tcc8800/obj/PACKAGING/target_files_intermediates/目录下,它是在用命令make otapackage之后的中间生产物,是最原始的升级包。我们将两次编译的生成的原始包分别重命名为A.zip和,并拷贝到SD卡根目录下重复执行上面的命令:

               $ ./build/tools/releasetools/ota_form_target_files -i。

              在上述命令即将执行完毕时,device/telechips/common/releasetools.py会调用IncrementalOTA_InstallEnd,在这个函数中 读取包中的RADIO/bootloader.img。