小米2c中update.zip是什么意思
全部答案（共1个回答）
嗨！这是卡刷。下面是卡刷的详细方法，您可以参考一下：请您提前备份，然后在小米官网下载个最新版的开发版卡刷包。链接/top...
这是在提示你升级。
网站上更新操作系统就是以此为工作之一修补系统漏洞
关机重启，应该就可以了
这是在提示你升级。
这个是安装包，先解压
答: 谁帮忙找下那个说小孩被吓到用小米怎么怎么的帖子
答: 美国苹果公司的新款手机，全触屏的智能机，在中国卖的很贵。
答: 手机购买还是找正规卖家
天猫等网站
答: 可能被设置了禁言你IP接入吧
大家还关注
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区
相关问答：123456789101112131415当前位置： &
> update.zip官方下载
update.zip官方(安卓服务升级包/刷机包) v9.11 免费版
android系统是智能机主流系统，今天小编为你带来最新update.zip官方下载文件，update.zip下载后你得到的就是安卓服务升级包/包，这是Root配置工具，同时也是Google服务升级包，update.zip官方版主要功能就是访问和修改你手机几乎所有的文件，update.zip是必备的文件！update.zip官方版使用方法：1. 设置手机连接模式成大容量模式连接至你的电脑，步骤2里面选择你要下载的zip文件，下载完毕后移动到你手机内存卡根目录下。2.将你的安卓手机关机。3.让你的手机进入recovery模式也即模式4.使用音量下键选择apply update from sdcard，再按HOME键选择机型在上面下载的zip文件。5.提示install from sdcard complete完成后，点击返回键，用音量键选择reboot system now这一项，点击后手机就会自动重启。6.获取root权限。
update.zip官方下载
高速下载器通道
其他下载地址
下载不了？
1.5MB | 简体中文 | 0分
目前在线刷机最好用的免root刷机工具就是移动叔叔刷机助手最新版！...
2.58 MB | 简体中文 | 0分
网上有更种各样的刷机软件，但是不懂啊，刷机刷不好手机就废了，有...
1 GB | 简体中文 | 0分
安卓6.0看齐的时代我们还在努力寻找android7.0版本么？一加安卓7.0...
425 MB | 简体中文 | 0分
网络机顶盒刷机工具想必很多用户也是需要的~这里小编准备一款英菲克...
11.04 MB | 简体中文 | 0分
最近想刷机的朋友可以看看小编带来的这flash fire刷机软件安卓版，...
17.38 MB | 简体中文 | 0分
想要刷机？那您可以下载我们的手机刷机精灵安卓版哦！这款手机刷机...
下载排行榜1425人阅读
android（23）
一、update.zip包目录结构详解
& & &1、boot.img是更新boot分区所需要的文件。这个boot.img主要包括kernel+ramdisk。
& & &2、system/目录的内容在升级后会放在系统的system分区。主要用来更新系统的一些应用或则应用会用到的一些库等等。可以将Android源码编译out/target/product/tcc8800/system/中的所有文件拷贝到这个目录来代替。
& & &3、recovery/目录中的recovery-from-boot.p是boot.img和recovery.img的补丁(patch),主要用来更新recovery分区，其中etc/目录下的install-recovery.sh是更新脚本。
& & &4、update-binary是一个二进制文件，相当于一个脚本解释器，能够识别updater-script中描述的操作。该文件在Android源码编译后out/target/product/tcc8800/system bin/updater生成，可将updater重命名为update-binary得到。该文件在具体的更新包中的名字由源码中bootable/recovery/install.c中的宏ASSUMED_UPDATE_BINARY_NAME的值而定。
& & &5、updater-script：此文件是一个脚本文件，具体描述了更新过程。我们可以根据具体情况编写该脚本来适应我们的具体需求。该文件的命名由源码中bootable/recovery/updater/updater.c文件中的宏SCRIPT_NAME的值而定。
& & &6、metadata文件是描述设备信息及环境变量的元数据。主要包括一些编译选项，签名公钥，时间戳以及设备型号等。
& & &7、我们还可以在包中添加userdata目录，来更新系统中的用户数据部分。这部分内容在更新后会存放在系统的/data目录下。
& & &8、update.zip包的签名：update.zip更新包在制作完成后需要对其签名，否则在升级时会出现认证失败的错误提示。而且签名要使用和目标板一致的加密公钥。加密公钥及加密需要的三个文件在Android源码编译后生成的具体路径为：
& & & & &out/host/Linux-x86/framework/signapk.jar&
& & & & &build/target/product/security/testkey.x509.pem & & & &&
& & & & &build/target/product/security/testkey.pk8 。
& & & & &我们用命令make otapackage制作生成的update.zip包是已签过名的，如果自己做update.zip包时必须手动对其签名。
& & & & &具体的加密方法：$ java –jar gingerbread/out/host/linux/framework/signapk.jar –w gingerbread/build/target/product/security/testkey.x509.pem & & & & & & & & & & & & & & & & & & &gingerbread/build/target/product/security/testkey.pk8
update.zip update_signed.zip
& & & & &以上命令在update.zip包所在的路径下执行，其中signapk.jar testkey.x509.pem以及testkey.pk8文件的引用使用绝对路径。update.zip 是我们已经打好的包，update_signed.zip包是命令执行完生成的已经签过名的包。
& & &9、MANIFEST.MF：这个manifest文件定义了与包的组成结构相关的数据。类似Android应用的mainfest.xml文件。
& & 10、CERT.RSA：与签名文件相关联的签名程序块文件，它存储了用于签名JAR文件的公共签名
& & 11、CERT.SF：这是JAR文件的签名文件，其中前缀CERT代表签名者。
二、Android升级包update.zip的生成过程分析
& & & & 1.命令制作。Android源码系统中为我们提供了制作update.zip刷机包的命令，即make otapackage。该命令在编译源码完成后并在源码根目录下执行。 具体操作方式：在源码根目录下执行
& & & & & & & & ①$ source build/envsetup.sh。&
& & & & & & & & ②$ lunch 然后选择你需要的配置(如17)。
& & & & & & & & ③$ make otapackage。
& & & & 2.使用make otapackage命令生成update.zip的过程分析。
& & & & & & 在源码根目录下执行make otapackage命令生成update.zip包主要分为两步，第一步是根据Makefile执行编译生成一个update原包（zip格式）。第二步是运行一个python脚本，并以上一步准备的zip包作为输入，最终生成我们需要的升级包。下面进一步分析这两个过程。
&span style=&font-size:14&&# A zip of the directories that map to the target filesystem.
# This zip can be used to create an OTA package or filesystem image
# as a post-build step.
name := $(TARGET_PRODUCT)
ifeq ($(TARGET_BUILD_TYPE),debug)
name := $(name)_debug
name := $(name)-target_files-$(FILE_NAME_TAG)
intermediates := $(call intermediates-dir-for,PACKAGING,target_files)
BUILT_TARGET_FILES_PACKAGE := $(intermediates)/$(name).zip
$(BUILT_TARGET_FILES_PACKAGE): intermediates := $(intermediates)
$(BUILT_TARGET_FILES_PACKAGE): \
zip_root := $(intermediates)/$(name)
# $(1): Directory to copy
# $(2): Location to copy it to
# The &ls -A& is to prevent &acp s/* d& from failing if s is empty.
define package_files-copy-root
if [ -d &$(strip $(1))& -a &$$(ls -A $(1))& ]; then \
mkdir -p $(2) && \
$(ACP) -rd $(strip $(1))/* $(2); \
built_ota_tools := \
$(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \
$(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \
$(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \
$(call intermediates-dir-for,EXECUTABLES,sqlite3)/sqlite3 \
$(call intermediates-dir-for,EXECUTABLES,updater)/updater
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_FSTAB_VERSION := $(RECOVERY_FSTAB_VERSION)
ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)
# default to common dir for device vendor
$(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common
$(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)
# Depending on the various images guarantees that the underlying
# directories are up-to-date.
$(BUILT_TARGET_FILES_PACKAGE): \
$(INSTALLED_BOOTIMAGE_TARGET) \
$(INSTALLED_RADIOIMAGE_TARGET) \
$(INSTALLED_RECOVERYIMAGE_TARGET) \
$(INSTALLED_SYSTEMIMAGE) \
$(INSTALLED_USERDATAIMAGE_TARGET) \
$(INSTALLED_CACHEIMAGE_TARGET) \
$(INSTALLED_VENDORIMAGE_TARGET) \
$(INSTALLED_ANDROID_INFO_TXT_TARGET) \
$(SELINUX_FC) \
$(built_ota_tools) \
$(APKCERTS_FILE) \
$(HOST_OUT_EXECUTABLES)/fs_config \
@echo &Package target files: $@&
$(hide) rm -rf $@ $(zip_root)
$(hide) mkdir -p $(dir $@) $(zip_root)
@# Components of the recovery image
$(hide) mkdir -p $(zip_root)/RECOVERY
$(hide) $(call package_files-copy-root, \
$(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)
ifdef INSTALLED_KERNEL_TARGET
$(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel
ifdef INSTALLED_2NDBOOTLOADER_TARGET
$(hide) $(ACP) \
$(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second
ifdef BOARD_KERNEL_CMDLINE
$(hide) echo &$(BOARD_KERNEL_CMDLINE)& & $(zip_root)/RECOVERY/cmdline
ifdef BOARD_KERNEL_BASE
$(hide) echo &$(BOARD_KERNEL_BASE)& & $(zip_root)/RECOVERY/base
ifdef BOARD_KERNEL_PAGESIZE
$(hide) echo &$(BOARD_KERNEL_PAGESIZE)& & $(zip_root)/RECOVERY/pagesize
@# Components of the boot image
$(hide) mkdir -p $(zip_root)/BOOT
$(hide) $(call package_files-copy-root, \
$(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)
ifdef INSTALLED_KERNEL_TARGET
$(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel
ifdef INSTALLED_2NDBOOTLOADER_TARGET
$(hide) $(ACP) \
$(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second
ifdef BOARD_KERNEL_CMDLINE
$(hide) echo &$(BOARD_KERNEL_CMDLINE)& & $(zip_root)/BOOT/cmdline
ifdef BOARD_KERNEL_BASE
$(hide) echo &$(BOARD_KERNEL_BASE)& & $(zip_root)/BOOT/base
ifdef BOARD_KERNEL_PAGESIZE
$(hide) echo &$(BOARD_KERNEL_PAGESIZE)& & $(zip_root)/BOOT/pagesize
$(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\
mkdir -p $(zip_root)/RADIO; \
$(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)
@# Contents of the system image
$(hide) $(call package_files-copy-root, \
$(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)
@# Contents of the data image
$(hide) $(call package_files-copy-root, \
$(TARGET_OUT_DATA),$(zip_root)/DATA)
ifdef BOARD_VENDORIMAGE_FILE_SYSTEM_TYPE
@# Contents of the vendor image
$(hide) $(call package_files-copy-root, \
$(TARGET_OUT_VENDOR),$(zip_root)/VENDOR)
@# Extra contents of the OTA package
$(hide) mkdir -p $(zip_root)/OTA/bin
$(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/
$(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/
@# Files that do not end up in any images, but are necessary to
@# build them.
$(hide) mkdir -p $(zip_root)/META
$(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt
$(hide)echo &$(PRODUCT_OTA_PUBLIC_KEYS)& & $(zip_root)/META/otakeys.txt
$(hide) echo &recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)& & $(zip_root)/META/misc_info.txt
$(hide) echo &fstab_version=$(PRIVATE_RECOVERY_FSTAB_VERSION)& && $(zip_root)/META/misc_info.txt
ifdef BOARD_FLASH_BLOCK_SIZE
$(hide) echo &blocksize=$(BOARD_FLASH_BLOCK_SIZE)& && $(zip_root)/META/misc_info.txt
ifdef BOARD_BOOTIMAGE_PARTITION_SIZE
$(hide) echo &boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)& && $(zip_root)/META/misc_info.txt
ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE
$(hide) echo &recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)& && $(zip_root)/META/misc_info.txt
$(hide) echo &tool_extensions=$(tool_extensions)& && $(zip_root)/META/misc_info.txt
$(hide) echo &default_system_dev_certificate=$(DEFAULT_SYSTEM_DEV_CERTIFICATE)& && $(zip_root)/META/misc_info.txt
ifdef PRODUCT_EXTRA_RECOVERY_KEYS
$(hide) echo &extra_recovery_keys=$(PRODUCT_EXTRA_RECOVERY_KEYS)& && $(zip_root)/META/misc_info.txt
$(hide) echo &mkbootimg_args=$(BOARD_MKBOOTIMG_ARGS)& && $(zip_root)/META/misc_info.txt
$(hide) echo &use_set_metadata=1& && $(zip_root)/META/misc_info.txt
$(hide) echo &update_rename_support=1& && $(zip_root)/META/misc_info.txt
$(call generate-userimage-prop-dictionary, $(zip_root)/META/misc_info.txt)
@# Zip everything up, preserving symlinks
$(hide) (cd $(zip_root) && zip -qry ../$(notdir $@) .)
@# Run fs_config on all the system, boot ramdisk, and recovery ramdisk files in the zip, and save the output
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS=&SYSTEM/& } /^SYSTEM\// {print &system/& $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) & $(zip_root)/META/filesystem_config.txt
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS=&BOOT/RAMDISK/& } /^BOOT\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) & $(zip_root)/META/boot_filesystem_config.txt
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS=&RECOVERY/RAMDISK/& } /^RECOVERY\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) & $(zip_root)/META/recovery_filesystem_config.txt
$(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/*filesystem_config.txt)
.PHONY: target-files-package
target-files-package: $(BUILT_TARGET_FILES_PACKAGE)
ifneq ($(TARGET_PRODUCT),sdk)
ifeq ($(filter generic%,$(TARGET_DEVICE)),)
ifneq ($(TARGET_NO_KERNEL),true)
ifneq ($(recovery_fstab),)&span style=&font-family: Arial, Helvetica, sans- background-color: rgb(255, 255, 255);&&
&/span&&/span&根据上面的Makefile可以分析这个包的生成过程：
& & 首先创建一个root_zip根目录，并依次在此目录下创建所需要的如下其他目录
& & 1）创建RECOVERY目录，并填充该目录的内容，包括kernel的镜像和recovery根文件系统的镜像。此目录最终用于生成recovery.img。
& &&2）创建并填充BOOT目录。包含kernel和cmdline以及pagesize大小等，该目录最终用来生成boot.img。
& &&3）向SYSTEM目录填充system image。
& &&4）向DATA填充data image。
& &&5）用于生成OTA package包所需要的额外的内容。主要包括一些bin命令。
& &&6）创建META目录并向该目录下添加一些文本文件，如apkcerts.txt(描述apk文件用到的认证证书)，misc_info.txt(描述Flash内存的块大小以及boot、recovery、system、userdata等分区的大小信息)。
& &&7）使用保留连接选项压缩我们在上面获得的root_zip目录。
& &&8）使用fs_config(build/tools/fs_config)配置上面的zip包内所有的系统文件(system/下各目录、文件)的权限属主等信息。fs_config包含了一个头文件#include“private/android_filesystem_config.h”。在这个头文件中以硬编码的方式设定了system目录下各文件的权限、属主。执行完配置后会将配置后的信息以文本方式输出 到META/filesystem_config.txt中。并再一次zip压缩成我们最终需要的原始包。
& & 然后上面的zip包只是一个编译过程中生成的原始包。这个原始zip包在实际的编译过程中有两个作用，一是用来生成OTA update升级包，二是用来生成系统镜像，在编译过程中若生成OTA update升级包时会调用（具体位置在Makefile的1037行到1058行）一个名为 ota_from_target_files 的Python脚本，位置在/build/tools/releasetools/ota_from_target_files。这个脚本的作用是以第一步生成的zip原始包作为输入，最终生成可用的OTA升级zip包。
& & 下面我们分析使用这个脚本生成最终OTA升级包的过程。
& & 首先看一下这个脚本开始部分的帮助文档。代码如下： &&&span style=&font-size:14&&# Copyright (C) 2008 The Android Open Source Project
# Licensed under the Apache License, Version 2.0 (the &License&);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an &AS IS& BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
Given a target-files zipfile, produces an OTA package that installs
that build.
An incremental OTA is produced if -i is given, otherwise
a full OTA is produced.
ota_from_target_files [flags] input_target_files output_ota_package
(--board_config)
Deprecated.
-k (--package_key) &key& Key to use to sign the package (default is
the value of default_system_dev_certificate from the input
target-files's META/misc_info.txt, or
&build/target/product/security/testkey& if that value is not
specified).
For incremental OTAs, the default value is based on the source
target-file, not the target build.
(--incremental_from)
Generate an incremental OTA using the given target-files zip as
the starting build.
(--wipe_user_data)
Generate an OTA package that will wipe the user data partition
when installed.
(--no_prereq)
Omit the timestamp prereq check normally included at the top of
the build scripts (used for developer OTA packages which
legitimately need to go back and forth).
(--extra_script)
Insert the contents of file at the end of the update script.
(--aslr_mode)
Specify whether to turn on ASLR for the package (on by default).
&/span&下面简单翻译一下他们的使用方法以及选项的作用。
& & Usage: ota_from_target_files [flags] input_target_files output_ota_package
& & -b 过时的。
& & -k签名所使用的密钥
& & -i生成增量OTA包时使用此选项。后面我们会用到这个选项来生成OTA增量包。
& & -w是否清除userdata分区
& &&-n在升级时是否不检查时间戳，缺省要检查，即缺省情况下只能基于旧版本升级。
& &&-e是否有额外运行的脚本
& &&-m执行过程中生成脚本(updater-script)所需要的格式,目前有两种即amend和edify。对应上两种版本升级时会采用不同的解释器。缺省会同时生成两种格式的脚 本。
& &&-p定义脚本用到的一些可执行文件的路径。
& &&-s定义额外运行脚本的路径。
& &&-x定义额外运行的脚本可能用的键值对。
& &&-v执行过程中打印出执行的命令。
& &&-h命令帮助
下面分析ota_from_target_files这个python脚本是怎样生成最终zip包的。先讲这个脚本的代码贴出来如下：
&span style=&font-size:14&&import sys
if sys.hexversion & 0x:
print && sys.stderr, &Python 2.4 or newer is required.&
sys.exit(1)
import copy
import errno
import subprocess
import tempfile
import time
import zipfile
from hashlib import sha1 as sha1
except ImportError:
from sha import sha as sha1
import common
import edify_generator
OPTIONS = common.OPTIONS
OPTIONS.package_key = None
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.aslr_mode = True
OPTIONS.worker_threads = 3
def MostPopularKey(d, default):
&&&Given a dict, return the key corresponding to the largest
Returns 'default' if the dict is empty.&&&
x = [(v, k) for (k, v) in d.iteritems()]
if not x: return default
return x[-1][1]
def IsSymlink(info):
&&&Return true if the zipfile.ZipInfo object passed in represents a
symlink.&&&
return (info.external_attr && 16) == 0120777
def IsRegular(info):
&&&Return true if the zipfile.ZipInfo object passed in represents a
symlink.&&&
return (info.external_attr && 28) == 010
def ClosestFileMatch(src, tgtfiles, existing):
&&&Returns the closest file match between a source file and list
of potential matches.
The exact filename match is preferred,
then the sha1 is searched for, and finally a file with the same
basename is evaluated.
Rename support in the updater-binary is
required for the latter checks to be used.&&&
result = tgtfiles.get(&path:& + src.name)
if result is not None:
return result
if not OPTIONS.target_info_dict.get(&update_rename_support&, False):
return None
if src.size & 1000:
return None
result = tgtfiles.get(&sha1:& + src.sha1)
if result is not None and existing.get(result.name) is None:
return result
result = tgtfiles.get(&file:& + src.name.split(&/&)[-1])
if result is not None and existing.get(result.name) is None:
return result
return None
class Item:
&&&Items represent the metadata (user, group, mode) of files and
directories in the system image.&&&
ITEMS = {}
def __init__(self, name, dir=False):
self.name = name
self.uid = None
self.gid = None
self.mode = None
self.selabel = None
self.capabilities = None
self.dir = dir
self.parent = Item.Get(os.path.dirname(name), dir=True)
self.parent.children.append(self)
self.parent = None
self.children = []
def Dump(self, indent=0):
if self.uid is not None:
print &%s%s %d %d %o& % (&
&*indent, self.name, self.uid, self.gid, self.mode)
print &%s%s %s %s %s& % (&
&*indent, self.name, self.uid, self.gid, self.mode)
if self.dir:
print &%s%s& % (&
&*indent, self.descendants)
print &%s%s& % (&
&*indent, self.best_subtree)
for i 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):
# The target_files contains a record of what the uid,
# gid, and mode are supposed to be.
output = input_zip.read(&META/filesystem_config.txt&)
for line in output.split(&\n&):
if not line: continue
columns = line.split()
name, uid, gid, mode = columns[:4]
selabel = None
capabilities = None
# After the first 4 columns, there are a series of key=value
# pairs. Extract out the fields we care about.
for element in columns[4:]:
key, value = element.split(&=&)
if key == &selabel&:
selabel = value
if key == &capabilities&:
capabilities = value
i = cls.ITEMS.get(name, None)
if i is not None:
i.uid = int(uid)
i.gid = int(gid)
i.mode = int(mode, 8)
i.selabel = selabel
i.capabilities = capabilities
i.children.sort(key=lambda i: i.name)
# set metadata for the files generated by this script.
i = cls.ITEMS.get(&system/recovery-from-boot.p&, None)
if i: i.uid, i.gid, i.mode, i.selabel, i.capabilities = 0, 0, 0644, None, None
i = cls.ITEMS.get(&system/etc/install-recovery.sh&, None)
if i: i.uid, i.gid, i.mode, i.selabel, i.capabilities = 0, 0, 0544, None, None
def CountChildMetadata(self):
&&&Count up the (uid, gid, mode, selabel, capabilities) 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
Recursively calls itself for all descendants.
Returns a dict of {(uid, gid, dmode, fmode, selabel, capabilities): count} counting up
all descendants of this node.
(dmode or fmode may be None.)
sets the best_subtree of each directory Item to the (uid, gid,
dmode, fmode, selabel, capabilities) tuple that will match the most
descendants of that Item.
assert self.dir
d = self.descendants = {(self.uid, self.gid, self.mode, None, self.selabel, self.capabilities): 1}
for i in self.children:
for k, v in i.CountChildMetadata().iteritems():
d[k] = d.get(k, 0) + v
k = (i.uid, i.gid, None, i.mode, i.selabel, i.capabilities)
d[k] = d.get(k, 0) + 1
# Find the (uid, gid, dmode, fmode, selabel, capabilities)
# tuple that matches the most descendants.
# First, find the (uid, gid) pair that matches the most
# descendants.
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, fmode, selabel, and capabilities that match
# the most descendants with that (uid, gid), and choose those.
best_dmode = (0, 0755)
best_fmode = (0, 0644)
best_selabel = (0, None)
best_capabilities = (0, None)
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])
if k[4] is not None and count &= best_selabel[0]: best_selabel = (count, k[4])
if k[5] is not None and count &= best_capabilities[0]: best_capabilities = (count, k[5])
self.best_subtree = ug + (best_dmode[1], best_fmode[1], best_selabel[1], best_capabilities[1])
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, selabel, capabilities) tuple that the current
# item (and all its children) have already been set to.
# 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.name, *item.best_subtree)
current = item.best_subtree
if item.uid != current[0] or item.gid != current[1] or \
item.mode != current[2] or item.selabel != current[4] or \
item.capabilities != current[5]:
script.SetPermissions(&/&+item.name, item.uid, item.gid,
item.mode, item.selabel, item.capabilities)
for i in item.children:
recurse(i, current)
if item.uid != current[0] or item.gid != current[1] or \
item.mode != current[3] or item.selabel != current[4] or \
item.capabilities != current[5]:
script.SetPermissions(&/&+item.name, item.uid, item.gid,
item.mode, item.selabel, item.capabilities)
recurse(self, (-1, -1, -1, -1, None, None))
def CopySystemFiles(input_zip, output_zip=None,
substitute=None):
&&&Copies files underneath system/ in the input zip to the output
Populates the Item class with their metadata, and returns a
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 list():
if info.filename.startswith(&SYSTEM/&):
basefilename = info.filename[7:]
if IsSymlink(info):
symlinks.append((input_zip.read(info.filename),
&/system/& + basefilename))
info2 = copy.copy(info)
fn = info2.filename = &system/& + basefilename
if substitute and fn in substitute and substitute[fn] is None:
if output_zip is not None:
if substitute and fn in substitute:
data = substitute[fn]
data = input_zip.read(info.filename)
output_zip.writestr(info2, data)
if fn.endswith(&/&):
Item.Get(fn[:-1], dir=True)
Item.Get(fn, dir=False)
symlinks.sort()
return symlinks
def SignOutput(temp_zip_name, output_zip_name):
key_passwords = common.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, info_dict):
device = GetBuildProp(&ro.product.device&, info_dict)
script.AssertDevice(device)
def MakeecoveryPatch(input_tmp, output_zip, recovery_img, boot_img):
&&&Generate a 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 a 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.
info should be the dictionary returned by
common.LoadInfoDict() on the input target_files.
Returns an Item for the shell script, which must be made
executable.
diff_program = [&imgdiff&]
path = os.path.join(input_tmp, &SYSTEM&, &etc&, &recovery-resource.dat&)
if os.path.exists(path):
diff_program.append(&-b&)
diff_program.append(path)
bonus_args = &-b /system/etc/recovery-resource.dat&
bonus_args = &&
d = common.Difference(recovery_img, boot_img, diff_program=diff_program)
_, _, 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&, _dict)
recovery_type, recovery_device = common.GetTypeAndDevice(&/recovery&, _dict)
sh = &&&#!/system/bin/sh
if ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(recovery_size)d:%(recovery_sha1)s; then
log -t recovery &Installing new recovery image&
applypatch %(bonus_args)s %(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
log -t recovery &Recovery image already installed&
&&& % { 'boot_size': boot_img.size,
'boot_sha1': boot_img.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,
'bonus_args': bonus_args,
common.ZipWriteStr(output_zip, &recovery/etc/install-recovery.sh&, sh)
return Item.Get(&system/etc/install-recovery.sh&, 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, _dict)
metadata = {&post-build&: GetBuildProp(&ro.build.fingerprint&,
&pre-device&: GetBuildProp(&ro.product.device&,
&post-timestamp&: GetBuildProp(&ro.build.date.utc&,
device_specific = common.DeviceSpecificParams(
input_zip=input_zip,
input__dict[&recovery_api_version&],
output_zip=output_zip,
script=script,
input_tmp=OPTIONS.input_tmp,
metadata=metadata,
info__dict)
if not OPTIONS.omit_prereq:
ts = GetBuildProp(&ro.build.date.utc&, _dict)
ts_text = GetBuildProp(&ro.build.date&, _dict)
script.AssertOlderBuild(ts, ts_text)
AppendAssertions(script, _dict)
device_specific.FullOTA_Assertions()
device_specific.FullOTA_InstallBegin()
script.ShowProgress(0.5, 0)
if OPTIONS.wipe_user_data:
script.FormatPartition(&/data&)
if &selinux_fc& _dict:
_dict[&selinux_fc&], output_zip)
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.GetBootableImage(&boot.img&, &boot.img&,
OPTIONS.input_tmp, &BOOT&)
recovery_img = common.GetBootableImage(&recovery.img&, &recovery.img&,
OPTIONS.input_tmp, &RECOVERY&)
MakeRecoveryPatch(OPTIONS.input_tmp, output_zip, recovery_img, boot_img)
Item.GetMetadata(input_zip)
Item.Get(&system&).SetPermissions(script)
common.CheckSize(boot_img.data, &boot.img&, _dict)
common.ZipWriteStr(output_zip, &boot.img&, boot_img.data)
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 WritePolicyConfig(file_context, output_zip):
f = open(file_context, 'r');
basename = os.path.basename(file_context)
common.ZipWriteStr(output_zip, basename, f.read())
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 a given target-files
ZipFile, and return a dict of {filename: File object}.&&&
for info list():
if info.filename.startswith(&SYSTEM/&) and not IsSymlink(info):
basefilename = info.filename[7:]
fn = &system/& + basefilename
data = z.read(info.filename)
out[fn] = common.File(fn, data)
return out
def GetBuildProp(prop, info_dict):
&&&Return the fingerprint of the build of a given target-files info_dict.&&&
return info_dict.get(&build.prop&, {})[prop]
except KeyError:
raise common.ExternalError(&couldn't find %s in build.prop& % (property,))
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 a source that &
&can't install it.&)
script = edify_generator.EdifyGenerator(source_version,
OPTIONS.target_info_dict)
metadata = {&pre-device&: GetBuildProp(&ro.product.device&,
OPTIONS.source_info_dict),
&post-timestamp&: GetBuildProp(&ro.build.date.utc&,
OPTIONS.target_info_dict),
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)
print &Loading target...&
target_data = LoadSystemFiles(target_zip)
print &Loading source...&
source_data = LoadSystemFiles(source_zip)
verbatim_targets = []
patch_list = []
diffs = []
renames = {}
largest_source_size = 0
matching_file_cache = {}
for fn in source_data.keys():
sf = source_data[fn]
assert fn == sf.name
matching_file_cache[&path:& + fn] = sf
# Only allow eligability for filename/sha matching
# if there isn't a perfect path match.
if target_data.get(sf.name) is None:
matching_file_cache[&file:& + fn.split(&/&)[-1]] = sf
matching_file_cache[&sha:& + sf.sha1] = sf
for fn in sorted(target_data.keys()):
tf = target_data[fn]
assert fn == tf.name
sf = ClosestFileMatch(tf, matching_file_cache, renames)
if sf is not None and sf.name != tf.name:
print &File has moved from & + sf.name + & to & + tf.name
renames[sf.name] = tf
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:
# F consider sending as a patch
diffs.append(common.Difference(tf, sf))
# Target file data identical to source (may still be renamed)
puteDifferences(diffs)
for diff in diffs:
tf, sf, d = diff.GetPatch()
if d is None or len(d) & tf.size * OPTIONS.patch_threshold:
# patch is almos don't bother patching
tf.AddToZip(output_zip)
verbatim_targets.append((tf.name, tf.size))
common.ZipWriteStr(output_zip, &patch/& + sf.name + &.p&, d)
patch_list.append((sf.name, tf, sf, tf.size, common.sha1(d).hexdigest()))
largest_source_size = max(largest_source_size, sf.size)
source_fp = GetBuildProp(&ro.build.fingerprint&, OPTIONS.source_info_dict)
target_fp = GetBuildProp(&ro.build.fingerprint&, OPTIONS.target_info_dict)
metadata[&pre-build&] = source_fp
metadata[&post-build&] = target_fp
script.Mount(&/system&)
script.AssertSomeFingerprint(source_fp, target_fp)
source_boot = common.GetBootableImage(
&/tmp/boot.img&, &boot.img&, OPTIONS.source_tmp, &BOOT&,
OPTIONS.source_info_dict)
target_boot = common.GetBootableImage(
&/tmp/boot.img&, &boot.img&, OPTIONS.target_tmp, &BOOT&)
updating_boot = (source_boot.data != target_boot.data)
source_recovery = common.GetBootableImage(
&/tmp/recovery.img&, &recovery.img&, OPTIONS.source_tmp, &RECOVERY&,
OPTIONS.source_info_dict)
target_recovery = common.GetBootableImage(
&/tmp/recovery.img&, &recovery.img&, OPTIONS.target_tmp, &RECOVERY&)
updating_recovery = (source_recovery.data != target_recovery.data)
# 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, OPTIONS.target_info_dict)
device_specific.IncrementalOTA_Assertions()
script.Print(&Verifying current system...&)
device_specific.IncrementalOTA_VerifyBegin()
script.ShowProgress(0.1, 0)
total_verify_size = float(sum([i[2].size for i in patch_list]) + 1)
if updating_boot:
total_verify_size += source_boot.size
so_far = 0
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:
d = common.Difference(target_boot, source_boot)
_, _, d = 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&, _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()
ment(&---- start making changes here ----&)
device_specific.IncrementalOTA_InstallBegin()
if OPTIONS.wipe_user_data:
script.Print(&Erasing user data...&)
script.FormatPartition(&/data&)
script.Print(&Removing unneeded files...&)
script.DeleteFiles([&/&+i[0] for i in verbatim_targets] +
[&/&+i for i in sorted(source_data)
if i not in target_data and
i not in renames] +
[&/system/recovery.img&])
script.ShowProgress(0.8, 0)
total_patch_size = float(sum([i[1].size for i in patch_list]) + 1)
if updating_boot:
total_patch_size += target_boot.size
so_far = 0
script.Print(&Patching system files...&)
deferred_patch_list = []
for item in patch_list:
fn, tf, sf, size, _ = item
if tf.name == &system/build.prop&:
deferred_patch_list.append(item)
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 a 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 & including.&
print & skipping.&
if updating_recovery:
# Recovery is generated as a patch using both the boot image
# (which contains the same linux kernel as recovery) and the file
# /system/etc/recovery-resource.dat (which contains all the images
# used in the recovery UI) as sources.
This lets us minimize the
# size of the patch, which must be included in every OTA package.
# For older builds where recovery-resource.dat is not present, we
# use only the boot image as the source.
MakeRecoveryPatch(OPTIONS.target_tmp, output_zip,
target_recovery, target_boot)
script.DeleteFiles([&/system/recovery-from-boot.p&,
&/system/etc/install-recovery.sh&])
print &re including as patch from boot.&
print &reco skipping.&
script.ShowProgress(0.1, 10)
target_symlinks = CopySystemFiles(target_zip, None)
target_symlinks_d = dict([(i[1], i[0]) for i 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 i in source_symlinks])
# Delete all the symlinks in source that aren't in target.
# needs to happen before verbatim files are unpacked, in case a
# symlink in the source is replaced by a 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&)
if len(renames) & 0:
script.Print(&Renaming files...&)
for src in renames:
print &Renaming & + src + & to & + renames[src].name
script.RenameFile(src, renames[src].name)
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))
to_create.append((dest, link))
script.DeleteFiles([i[1] for i 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:
script.AppendExtra(OPTIONS.extra_script)
# Patch the build.prop file last, so if something fails but the
# device can still come up, it appears to be the old build and will
# get set the OTA package again to retry.
script.Print(&Patching remaining system files...&)
for item in deferred_patch_list:
fn, tf, sf, size, _ = item
script.ApplyPatch(&/&+fn, &-&, tf.size, tf.sha1, sf.sha1, &patch/&+fn+&.p&)
script.SetPermissions(&/system/build.prop&, 0, 0, 0644, None, None)
script.AddToZip(target_zip, output_zip)
WriteMetadata(metadata, output_zip)
def main(argv):
def option_handler(o, a):
if o in (&-b&, &--board_config&):
# deprecated
elif o in (&-k&, &--package_key&):
OPTIONS.package_key = a
elif o in (&-i&, &--incremental_from&):
OPTIONS.incremental_source = a
elif o in (&-w&, &--wipe_user_data&):
OPTIONS.wipe_user_data = True
elif o in (&-n&, &--no_prereq&):
OPTIONS.omit_prereq = True
elif o in (&-e&, &--extra_script&):
OPTIONS.extra_script = a
elif o in (&-a&, &--aslr_mode&):
if a in (&on&, &On&, &true&, &True&, &yes&, &Yes&):
OPTIONS.aslr_mode = True
OPTIONS.aslr_mode = False
elif o in (&--worker_threads&):
OPTIONS.worker_threads = int(a)
return False
return True
args = common.ParseOptions(argv, __doc__,
extra_opts=&b:k:i:d:wne:a:&,
extra_long_opts=[&board_config=&,
&package_key=&,
&incremental_from=&,
&wipe_user_data&,
&no_prereq&,
&extra_script=&,
&worker_threads=&,
&aslr_mode=&,
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, input_zip = common.UnzipTemp(args[0])
OPTIONS.target_tmp = OPTIONS.input_tmp
_dict = common.LoadInfoDict(input_zip)
# If this image was originally labelled with SELinux contexts, make sure we
# also apply the labels in our new image. During building, the &file_contexts&
# is in the out/ directory tree, but for repacking from target-files.zip it's
# in the root directory of the ramdisk.
if &selinux_fc& _dict:
_dict[&selinux_fc&] = os.path.join(OPTIONS.input_tmp, &BOOT&, &RAMDISK&,
&file_contexts&)
if OPTIONS.verbose:
print &--- target info ---&
common._dict)
if OPTIONS.device_specific is None:
OPTIONS.device_specific = _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
temp_zip_file = tempfile.NamedTemporaryFile()
output_zip = zipfile.ZipFile(temp_zip_file, &w&,
compression=zipfile.ZIP_DEFLATED)
if OPTIONS.incremental_source is None:
WriteFullOTAPackage(input_zip, output_zip)
if OPTIONS.package_key is None:
OPTIONS.package_key = _dict.get(
&default_system_dev_certificate&,
&build/target/product/security/testkey&)
print &unzipping source target-files...&
OPTIONS.source_tmp, source_zip = common.UnzipTemp(OPTIONS.incremental_source)
OPTIONS.target_info_dict = _dict
OPTIONS.source_info_dict = common.LoadInfoDict(source_zip)
if OPTIONS.package_key is None:
OPTIONS.package_key = OPTIONS.source_info_dict.get(
&default_system_dev_certificate&,
&build/target/product/security/testkey&)
if OPTIONS.verbose:
print &--- source info ---&
common.DumpInfoDict(OPTIONS.source_info_dict)
WriteIncrementalOTAPackage(input_zip, source_zip, output_zip)
output_zip.close()
SignOutput(temp_zip_file.name, args[1])
temp_zip_file.close()
common.Cleanup()
print &done.&
if __name__ == '__main__':
common.CloseInheritedPipes()
main(sys.argv[1:])
except common.ExternalError, e:
ERROR: %s& % (e,)
sys.exit(1)
&/span&主函数main是python的入口函数，我们从main函数开始看，大概看一下main函数（脚本最后）里的流程就能知道脚本的执行过程了。
& & 1) 在main函数的开头，首先将用户设定的option选项存入OPTIONS变量中，它是一个python中的类。紧接着判断有没有额外的脚本，如果有就读入到OPTIONS变量中。
& &&2) 解压缩输入的zip包，即我们在上文生成的原始zip包。然后判断是否用到device-specific extensions（设备扩展）如果用到，随即读入到OPTIONS变量中。
& &&3) 判断是否签名，然后判断是否有新内容的增量源，有的话就解压该增量源包放入一个临时变量中（source_zip）。自此，所有的准备工作已完毕，随即会调用该脚本中最主要的函数WriteFullOTAPackage(input_zip,output_zip)
& &&4) WriteFullOTAPackage函数的处理过程是先获得脚本的生成器。默认格式是edify。然后获得metadata元数据，此数据来至于Android的一些环境变量。然后获得设备配置参数比如api函数的版本。然后判断是否忽略时间戳。
& &&5) WriteFullOTAPackage函数做完准备工作后就开始生成升级用的脚本文件(updater-script)了。生成脚本文件后将上一步获得的metadata元数据写入到输出包out_zip。
& &&6) 至此一个完整的update.zip升级包就生成了。生成位置在：out/target/product/tcc8800/full_tcc8800_evm-ota-eng.mumu.326.zip。将升级包拷贝到SD卡中就可以用来升级了。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：23106次
排名：千里之外
原创：51篇
(2)(3)(1)(2)(4)(2)(4)(1)(2)(1)(3)(3)(1)(2)(2)(5)(5)(3)(7)