1301人阅读
eclipse erro/eclipse（19）
该错误是在使用gson.fromjson时出现的，原因是json格式数据的格式有误，可能首尾多了引号
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：133685次
积分：5214
积分：5214
排名：第5211名
原创：435篇
转载：29篇
评论：11条
(6)(49)(55)(47)(30)(48)(41)(13)(34)(41)(30)(32)(21)(17)好久没写文了。这是一篇关于easyui配合ajax使用 的文章， 顺带介绍angularjs的使用 以及让你感受到angularjs的威力。网上对于ajax 的文也是多如牛毛 。我就不直接 从那种原生的httpxmlrequest 对象的js 写起了哈。 看那种东西也存粹是了解 高层的东西是怎么来的 原理是啥 真正做的时候写那种东西 不是扯淡么& 你叼 你技术牛逼 整站的代码你全用那种写。html js 这种东西最开始设计出来就没考虑周全 就是坨屎。还好现在有各种框架 可以帮助我们更容易的把这坨屎做的更美味。也还好由于互联网事业如日中天 的推动 让浏览器端的这堆东西正在往统一规范的方向发展。&好了 正题。
我们来建立一个webform页面 HelloAjaxNet.aspx。先说下ajax 这里我使用网上流传甚广的那个AjaxPro.2.dll& 他的网站是 / 这是一个个人作品 ，很好用。
本来新的asp.net 里自带了 服务端方法用webmethod 属性声明 &客户端pagemethods访问 的方式 ，各种对象也可以json数据化 ，功能跟上面一样的。微软自带的是aspx的codebehind 代码方法 一定要加static& ，至于webconfig 在新版的vs2013开发环境下无须配置 如果是老的则新建ajax网站项目则webconfig自动弄好了然后服务端页面载入事件中 ScriptManager.GetCurrent(Page).EnablePageMethods = 客户端 必须有runat=server 的form 和&&asp:ScriptManager ID="ScriptManager1" runat="server"&&&&&&&& &/asp:ScriptManager&& 然后客户端就可以pagemethods 的方式访问。
我始终还是认为上面那个更好用 。关于他的原理我就不多说了& ，通过页面载入时注册服务端对象 ，然后生成的html页面上就多了这么几句
1 &script type="text/javascript" src="/ajaxpro/prototype.ashx"&&/script&
2 &script type="text/javascript" src="/ajaxpro/core.ashx"&&/script&
3 &script type="text/javascript" src="/ajaxpro/converter.ashx"&&/script&
4 &script type="text/javascript" src="/ajaxpro/WebApplication1.StudentsInfo,WebApplication1.ashx"&&/script&
5 &script type="text/javascript" src="/ajaxpro/WebApplication1.Grad,WebApplication1.ashx"&&/script&
6 &script type="text/javascript" src="/ajaxpro/WebApplication1.NewFolder2.HelloAjaxNet,WebApplication1.ashx"&&/script&
7 &script type="text/javascript" src="/ajaxpro/WebApplication1.DataEntity,WebApplication1.ashx"&&/script&
为是什么呢 为的是引用一段js文件 ajaxpro/WebApplication1.NewFolder2.HelloAjaxNet,WebApplication1.ashx&&
然后你就明白了噻 这段客供你进行客户端js调用的脚本&是服务端自动生成的 跟你 服务端的名字一模一样 然后你就可以貌似像在客户端回调服务端方法样的 没什么神奇的，我们主要就是想利用他的这个特性和json化数据的方便之处 来实现客户端服务端数据的无缝传递。
关于json数据的序列化 要是以前就只有利用外部json库 或者微软自带的来进行手动解析：
1 public string ServerProcerMethod4(string stu)
//System.Web.Script.Serialization.JavaScriptSerializer jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
//StuInfo s= jsSerializer.Deserialize&StuInfo&(stu);
System.Web.Script.Serialization.JavaScriptSerializer jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
List&StuInfo& s = jsSerializer.Deserialize&List&StuInfo&&(stu);
if (s != null && s.Count & 0)
StuInfo stu2= s[0];
StringBuilder sb = new StringBuilder();
jsSerializer.Serialize(stu2, sb);
return sb.ToString();
return null;
1 //javascript 字符串转json对象：
3 var obj = JSON.parse(str);
5 //javascript json 对象转字符串：
7 JSON.stringify(obj);
关于AjaxPro.2.dll& 和ajax.dll的关系 ，网上说他们不一样 其实压根就是一个人搞的吧 我擦 。请在上面网站下载ajaxpro 这个才是完善的版本
引用dll文件后需要配置webconfig&httphandler 作用就是让 上面的ashx请求转到我们的 ajaxpro代码 ，进而让我们的客户端js直接调用服务端方法调用成功。
1 &system.webServer&
&directoryBrowse enabled="true"/&
&handlers&
&add verb="*" path="*.ashx" name="myhandler" type="AjaxPro.AjaxHandlerFactory,AjaxPro.2"/&
&!--&add verb="POST,GET" path="ajax/*.ashx" name="myhandler" type="Ajax.PageHandlerFactory, Ajax" /&--&
&/handlers&
&/system.webServer&
然后其他的我就不多说了哈待会直接看服务端代码。
easyui 你就可以理解为一堆扩展了的控件。就像jquery一样 你把js对象 原生的html控件用他的东西一包 然后就可以点得出他一些为你写好的方法 帮助你方便的处理数据。并且还有默认的还可以的控件外观，这点对于做企业管理类软件来说 还是真心不错的，做其他的就只能呵呵了。下载easyui的文件 放到项目中 并引入easyui 相关js和样式文件 还有jquery：
&script type="text/javascript" src="../jquery-easyui-1.4.3/jquery.min.js"& &/script&
&link rel="stylesheet" type="text/css" href="../jquery-easyui-1.4.3/themes/default/easyui.css" /&
&link rel="stylesheet" type="text/css" href="../jquery-easyui-1.4.3/themes/icon.css" /&
&script type="text/javascript" src="../jquery-easyui-1.4.3/jquery.easyui.min.js"&&/script&
然后 ，然后你就可以使用easyui了 就像easyui 首页 / 上介绍的那样 通过css样式 或者js代码 把原生html控件渲染成easyui控件
1 &div class="easyui-dialog" style="width:400height:200px"
data-options="
title:'My Dialog',
iconCls:'icon-ok',
onOpen:function(){}"&
dialog content.
1 &input id="cc" style="width:200px" /&
3 $('#cc').combobox({
required: true,
valueField: 'id',
textField: 'text'
是的 非常方便。其实国内还有好些js写的比较牛的 弄了一些这样ui 那样ui 选来选去还是用这个吧。用的最多的需求就是ajax服务端分页 ，我们来弄个吧。
我们先说下这个easyui的datagrid& 打他狗日的，客户端html放个table标签 ：&table id="studb"&&/table& 然后用js这么一搞 $('#studb').datagrid() 他就给你渲染成easyui datagrid控件了 ，你可以在document.ready()时做这个事情。我们的数据表格是需要填充数据的 这些数据从哪来 显示哪些列 怎么分页 每页显示多少条，这些都是参数，怎么传进去。easyui很多地方都接收json对象形式的一坨参数 ，比如这个datagrid：
1 function bindDataToTb() {
var keywordStr = $('#keyword').val();
$('#studb').datagrid(
queryParams: { keyword: keywordStr },
//url:"WebForm2.aspx/BindData",
toolbar: '#searchBar',
pagination: true,
pageNumber: 1,
singleSelect: true,
pageSize: 5,
pageList: [5, 10, 20],
loader: function (param, success, error) {
var da = WebApplication1.NewFolder2.HelloAjaxNet.BindData(param.keyword, param.page, param.rows)
if (da.value.rows == null) {
success();
success(da.value);
pagePosition: 'bottom',
columns: [[
{ field: 'stuNo', title: 'Id', width: 100 },
{ field: 'name', title: '名字', width: 100 },
{ field: 'age', title: '年龄', width: 100 },
{ field: 'loginName', title: '登录名', width: 100 },
{ field: 'loginPwd', title: '密码', width: 100 },
{ field: 'GradId', title: '班级Id', width: 100 },
{ field: 'gradName', title: '班级', width: 100 },
field: 'none', title: '操作', width: 100, formatter: function (value, row, index) {
var btn = '&a class="editcls" href="#" onclick="delstuClick(' + row.stuNo + ')"&删除&/a&';
具体看loader 和columns ，loader用于定义你以什么形式载入数据 定义了loader上面的url就没有必要了。
我这里的WebApplication1.NewFolder2.HelloAjaxNet.BindData(param.keyword, param.page, param.rows) 自然也是服务端的方法 用于检索数据的 。
关于这三个param.keyword, param.page, param.rows 是我们用于实现loader时 easyui那种设计方式故意暴露给我们的参数 方便我们使用。
param.keyword 是我们上面定义的 我们点搜索的时候需要往服务端传一个查询关键词 queryParams: { keyword: keywordStr }
param.page 是easyui自己的参数表示当前第几页 param.rows表示每页行数，每当你 点表格的 上一页 下一页 的时候 就会自动往loader 发翻页的参数 这个是自动的。
然后就从服务端获取数据填充表格 ，就是这么一个工作过程。 还有colums 我就不说了就是定义显示哪些列 和自定义列 那个很容易看懂。
easyui控件有属性 方法，调用方法 的形式总算像这样 ：$('#studb').datagrid('reload')& 这就相当于调用了#studb这个表格控件的reload方法了 然后数据就会自动刷新，每个控件的具体见文档。
服务端数据处理我们还是用entityframework 我一般都用codefirst的方式 这东西跟他自己的mssql数据库 结合的很好 用起很方便。
服务端代码：
1 //查询（带分页
[AjaxPro.AjaxMethod]
public static WebApplication1.DataEntity BindData(string keyword, int page, int rows)
//, ref int pageIndex, out int totalPage
if (keyword == null)
keyword = "";
int pageIndex = 1;
int pageSize = 3;
int totalP
if (page != 0)
pageIndex =
if (rows != 0)
pageSize =
MyDb db = new MyDb();
var data = from studentInfo in db.Students where studentInfo.name.Contains(keyword) select new { stuNo = studentInfo.stuNo, name = studentInfo.name, age = studentInfo.age, gradName = studentInfo.grad.gradName };
//var data = from studentInfo in db.Students where studentInfo.name.Contains(keyword) select studentI
totalPage = data.Count() % pageSize == 0 ? data.Count() / pageSize : data.Count() / pageSize + 1;
if (pageIndex & totalPage)
pageIndex = totalP
else if (pageIndex & 1)
pageIndex = 1;
//var dt = DataList&object&.Create(data.OrderBy(r =& r.stuNo), new StudentsInfo(), pageIndex, pageSize).V
object dt=null ;
if(data.Count()&0)
dt= DataList&object&.Create(data.OrderBy(r =& r.stuNo),
new { stuNo = 1, name = "", age = 1, gradName = "" }, pageIndex, pageSize).V
WebApplication1.DataEntity result = new WebApplication1.DataEntity();
result.total = data.Count();
result.rows =
关于数据部分 和EF linq 分页那些我就不贴出来了 完整示例下载里面有。走走看吧 试试看吧 完全无刷新 服务端分页，感觉棒棒哒
搜索那个我也不想说了哈 就是重新载入下数据而已，删除是通过自定义 列的方式 传id到js函数 然后调用服务端删除。然后要说下 录入功能 以及easyui自带 的表单验证也是相当方便的。
新建一个div 作为弹出层 里面有一个录入信息的表格 各种html控件 只要写上easyui对应的样式& 就自动渲染了 看弹出层的 &class="easyui-dialog" data-options="closed:true,title:'新学生注册',modal:true"
其实很简单噻看字面意思就明白了 这些参数 都在easyui的文档里有。验证 也是在html元素上写data-options 就可以了， ：
1 &div id="addBox" class="easyui-dialog" data-options="closed:true,title:'新学生注册',modal:true" style="width: 400 height: 150px"&
&table class="auto-style1"&
&td&学生姓名：&/td&
&input id="stuname" class=" easyui-textbox" data-options="required:true,missingMessage:'必填项！',validType:'email',invalidMessage:'email格式不正确！'" type="text" /&&/td&
&td&班级： &/td&
&input class="easyui-combobox" id="grad" name="grad"
data-options="valueField:'id',textField:'gradName',required:true,missingMessage:'必填项！'" /&&/td&
&input id="saveBtn" onclick="saveClick()" type="button" value="保存" /&&/td&
&input id="Button1" type="button" onclick="$('#addBox').dialog('close');" value="关闭" /&&/td&
新建按钮：
1 &a id="Button1" onclick="$('#addBox').dialog('open');" class="easyui-linkbutton"&加新的&/a&
注意千万别用button 元素& 就是这种 &button&新加的&/button&& 这是个坑 ，折腾了好久。
保存按钮调用 的js函数：
1 //保存信息
function saveClick() {
var isvaliok = $("#addBox").form('validate');//包起来的需要提交信息的那个div框的id
if (isvaliok == false) {
$.messager.show({ title: '提示', msg: '请完善不正确的项后再提交', showType: 'show' });
var stu = {};
stu.name = $("#stuname").val();
stu.age = 22;
stu.GradId = $("#grad").combobox('getValue');
stu.gradName = $("#grad").combobox('getValue');
if (isNaN(stu.GradId))
stu.GradId = null;
var rst = WebApplication1.NewFolder2.HelloAjaxNet.addStu(stu);
if (rst.value == "ok") {
$('#addBox').dialog('close');
$('#studb').datagrid('reload');
var gradData = WebApplication1.NewFolder2.HelloAjaxNet.getGrad().
$('#grad').combobox({ data: gradData }).combobox('reload');
$.messager.show({ title: '提示', msg: rst.error.Message + rst.value, showType: 'show' });
注意到了噻：
1 var isvaliok = $("#addBox").form('validate');//包起来的需要提交信息的那个div框的id
if (isvaliok == false) {
$.messager.show({ title: '提示', msg: '请完善不正确的项后再提交', showType: 'show' });
在easyui里进行验证很简单噻 只要在html代码里把验证格式定义好了 ，只需要传入一个最外面容器控件的id $("#addBox").form('validate') 就自动帮我们验证了。并且界面上还有提示&焦点自动放到第一个验证不通过的控件上去了 完全不需要我们动手。
当然我们在客户端 document.ready()的时候 必须要绑定表格和下拉框的数据：
1 $(function () {
//页面初始化
//载入表格数据
bindDataToTb();
//载入班级下拉框
var gradData = WebApplication1.NewFolder2.HelloAjaxNet.getGrad().
$('#grad').combobox({ data: gradData }).combobox('reload');
var fd = new FormData();
服务端保存的代码：
[AjaxPro.AjaxMethod]
public string addStu(StudentsInfo stu)
MyDb db = new MyDb();
if(stu.GradId==null)
if (string.IsNullOrEmpty(stu.gradName) == false)
Grad grd = new Grad();
grd.gradName = stu.gradN
Grad grdOld = db.grads.FirstOrDefault(r =& r.gradName == stu.gradName);
if(grdOld!=null)
return "类别已存在";
db.grads.Add(grd);
stu.grad =
db.Students.Add(stu);
db.SaveChanges();
return "ok";
服务端代码 &如果我们没有这个id的类别我们就认为这个类别是新的 ，新加一个类别 然后立即绑定 perfect 完美 ，棒棒哒
看上去是不是有模有样。做管理类软件还行。
这样ui 那样ui当你需要自定义样式的时候发现什么ui都是浮云，例如我说的国内的写js比较牛的 就已经造出来很多ui了 ，表格是很漂亮 很强大。 其实很多功能你还是用不到 你想改还很困难 当然我的js也是很菜的。 当你用到另一套ui 的时候又要熟悉它那一套 。我只想用个简简单单的自定义分页表格而已 或者像asp.net里的服务器控件repeat 流式布局&四个数据一行那种 你怎么做。 还是自己动手吧。php里面有前端模板。
我这里只是简单从实际需求了解下angular的威力 php里面模板什么的都是浮云 & 新建一个webform& HelloAjaxNetAngular.aspx
注意这个例子& 服务端代码我一律用上面的丝毫都不会变 只是前端变了，angularjs 的主打思想是mvvm 模式 就是wpf里面那种依赖属性 动态绑定 ，不知道你们用过没 反正我用过 感觉就一个字 爽 ，做这种数据库平台程序 mfc winform 都是渣。
angularjs 的基础我就不介绍了 哈 直接从需求入手 做一个分页表格 加 信息更新 功能
angularjs的网站是 http://www.angularjs.org/ 这个网址在国内也是访问不了的。一些相关的其他人的学习笔记有 / /angular.html
反正这两个教程看了下对我没 对我没起到啥作用 感觉跟嚼木渣样的 ，angularjs的理念虽然是mvvm 但是angularjs本身还是感觉晦涩难懂。
我就在这样一个半懂不懂的状态下写了这个例子 ，所有的操作 几乎都完全不需要向jquery那样动dom 。真心感觉到了他的强大。前端就一个controller函数 管整个页面，怎么一个一个的分 我也不明白 只知道controller 跟html限定一样的树状结构。没在范围的html元素不能访问其controller里的 变量。我们来看这个controller 函数 ，我写的时候也没什么感觉 。就是感觉很存粹 就只感觉到两个东西存在 。业务逻辑在操作数据。 就像在写c#数据操作代码样：
1 function myCtr($scope) {
var mod = [{ name: 'xiang', age: 21 }, { name: 'xiang', age: 25 }, { name: 'xiang', age: 23 }];
$scope.data =
$scope.curobj = {};
$scope.pageEntity = { total: 0, rows: 5, page: 1, pgmsg: '' }
//初始化默认第一页
$scope.initPage = function () {
var firstPage = WebApplication1.NewFolder2.HelloAjaxNetAngular1.BindData($("#txtkeyword").val(), $scope.pageEntity.page, $scope.pageEntity.rows);
$scope.data = firstPage.value.
var pageEntityMod = {};
pageEntityMod.total = firstPage.value.
pageEntityMod.rows = $scope.pageEntity.
pageEntityMod.page = $scope.pageEntity.
var totalpage = pageEntityMod.total % pageEntityMod.rows == 0 ?
parseInt(pageEntityMod.total / pageEntityMod.rows) :
parseInt(pageEntityMod.total / pageEntityMod.rows) + 1;
pageEntityMod.pgmsg = "共 " + pageEntityMod.total + "条记录 每页 " + pageEntityMod.rows
+ "条，共 " + totalpage + "页 ，当前第 " + pageEntityMod.page + "页";
$scope.pageEntity = pageEntityM
$scope.curobj = {};
//更新当前 选定的
$scope.modifyCur = function () {
var rst = WebApplication1.NewFolder2.HelloAjaxNetAngular1.updateStu($scope.curobj)
//刷新表格 当前选中信息 复原
$scope.initPage();
alert(rst.value);
$scope.nextPage = function () {
var totalpage = $scope.pageEntity.total % $scope.pageEntity.rows == 0 ?
parseInt($scope.pageEntity.total / $scope.pageEntity.rows) :
parseInt($scope.pageEntity.total / $scope.pageEntity.rows) + 1;
var pagenewnum = $scope.pageEntity.page + 1;
if (pagenewnum &= totalpage)
$scope.pageEntity.page += 1;
$scope.initPage();
$scope.previousPage = function () {
var pagenewnum = $scope.pageEntity.page - 1;
if (pagenewnum &= 1)
$scope.pageEntity.page -= 1;
$scope.initPage();
$scope.search = function () {
//选中一行
$scope.del = function (sender, curobj) {
//所有行的颜色还原//设置选中那一行的颜色
var rows = $(sender.target).parent().parent().parent().find("tbody").find("tr");
for (var i = 0; i & rows. i++) {
$(rows[i]).css("background", "white");
$(sender.target).parent().css("background", "#ffe48d");
$scope.curobj =
//首次先调用下 以获取第一页
$scope.initPage();
界面部分：
1 &div ng-controller="myCtr" id="mygrid"&
&input id="txtkeyword" type="text" /&&input ng-click="initPage()" type="button" value="搜索" /&
&div style="height: 200px"&
&table cellspacing="0" border="1" class="gridtable"&
&th width="150px"&name&/th&
&th width="150px"&age&/th&
&tbody ng-repeat="stu in data"&
&tr ng-click='del($event,stu)' style="background-color: white"&
&td&{{stu.name}}&/td&
&td&{{stu.age}}&/td&
&div id="pager"&
&a href="#" ng-click="previousPage()"&上一页&/a& &a href="#" ng-click="nextPage()"&下一页&/a&
&span&{{pageEntity.pgmsg}}&/span&
姓名：&input type="text" value="{{curobj.name}}" ng-model="curobj.name" /&&br /&
年龄：&input type="text" value="{{curobj.age}}" ng-model="curobj.age" /&
&input id="Button1" type="button" ng-click="modifyCur()" value="更改" /&
看到我自己搞了一个数据绑定函数 参照easyui里datagrid的loader。 &第一次请求得到分页信息后 我立即把数据绑定到表格 你可以看到完全就像做模板样的，然后初始化自己的分页控件。 在ng-click 的时候像原来一样触发客户端单击 然后调用controller里的方法去更新数据 ，注意仅仅是根据业务逻辑去更新数据 其他的不需要做。关于上面两段代码不明白的自行去看angularjs 入门和数据绑定 用不了10分钟，
由于有wpf那种双向绑定机制，数据模型 数据更新了 页面内容自动跟着变。甚至你可以看到我编辑下面文本框里的数据的时候 都还没提交 上面表格的数据就跟着变 因为他们的数据是从同一个地方来的，看着恍惚都感觉是ajax哈。
上面所有 可直接运行，由于引了些外部库进来十兆差点放不下
其实照互联网这样推动发展下去的话 前端会统一 前端才是王道 到时候一个网页 就是一个系统 一个客户端。 后端只负责数据和安全。 现在的什么html5不是几乎都成为工业标准了么 有些嵌入式设备都支持
暂时像博客园里我看到的有几个讲的 前后端天人合一的那种mvc模式 前端后端操作同一个model 前端更新属性了有一种机制自动就更新到后端持久化到数据库去了& 或者后端更新model的某个属性 前端html页面的值自动就变了。 不是说做不到 毕竟牛人这么多 ，我觉得至少还不稳定吧。
各种ui有easyui ligerui fineui miniui& Devexpress 还有很多js框架 seajs requirejs JavaScriptMVC& backbone avalonjs knockout angular jquery jqueryui js真是屎一样的东西啊各种框架学都学不完
尤其是软件行业日新月异 基于框架 和平台的技术太多了 不精通某样技术没关系 能使用就行 ，但是作为一个技术人员 你至少得精通一样 或者一门技术 要不然就是个搬砖的 很遗憾 我基本还在搬砖的路上。写业务代码就是用一年的经验混十年，写业务代码是他的工作 工作之余还得有点精神追究 研究下事情的本质 ，只要是还不错的程序员 做这种数据库系统久了都会自己搞点能快速开发的所谓的小框架 积累一些自己的工具库 和经验。
在工作上不要有什么偏见& 只要他每天把业务代码写的出来 软件开发也只是一门职业 你不是英雄 ，目的是解决问题 不是转牛角尖。
我本人对js是不怎么感冒的 js也很烂，当初设计这个东西的时候就不完善给我们使用它造成了各种阻碍 ，但是你做web开发又不得不用它。这里也并不是对做前端的有什么偏见 感谢那些前端吃的很透的人 像司徒正美那些高手 制造了这些工具让我们更容易的去完成这些网站程序。
阅读(...) 评论()Android系统Recovery工作原理之使用update.zip升级过程分析
转自： & & &http://blog.csdn.net/mu0206mu
& & & & &这篇及以后的篇幅将通过分析update.zip包在具体Android系统升级的过程，来理解Android系统中Recovery模式服务的工作原理。我们先从update.zip包的制作开始，然后是Android系统的启动模式分析，Recovery工作原理，如何从我们上层开始选择system update到重启到Recovery服务，以及在Recovery服务中具体怎样处理update.zip包升级的，我们的安装脚本updater-script怎样被解析并执行的等一系列问题。分析过程中所用的Android源码是gingerbread0919（tcc88xx开发板标配的），测试开发板是tcc88xx。这是在工作中总结的文档，当然在网上参考了不少内容，如有雷同纯属巧合吧，在分析过程中也存在很多未解决的问题，也希望大家不吝指教。
一、&update.zip包的目录结构
& & & & & |----boot.img
& & & & & |----system/
& & & & & |----recovery/
& & & & & & & & `|----recovery-from-boot.p
& & & & & & & & `|----etc/
& & & & & & & & & & & & `|----install-recovery.sh
& & & & & |---META-INF/
& & & & & & & `|CERT.RSA
& & & & & & & `|CERT.SF
& & & & & & & `|MANIFEST.MF
& & & & & & & `|----com/
& & & & & & & & & & &`|----google/
& & & & & & & & & & & & & & &`|----android/
& & & & & & & & & & & & & & & & & & `|----update-binary
& & & & & & & & & & & & & & & & & & `|----updater-script
& & & & & & & & & & & & & & &`|----android/
& & & & & & & & & & & & & & & & & & `|----metadata
二、&update.zip包目录结构详解
& & & & &以上是我们用命令make otapackage 制作的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代表签名者。
& & & & 另外，在具体升级时，对update.zip包检查时大致会分三步：①检验SF文件与RSA文件是否匹配。②检验MANIFEST.MF与签名文件中的digest是否一致。③检验包中的文件与MANIFEST中所描述的是否一致。
三、&Android升级包update.zip的生成过程分析
& & & & &1) 对于update.zip包的制作有两种方式，即手动制作和命令生成。
& & & & &&第一种手动制作：即按照update.zip的目录结构手动创建我们需要的目录。然后将对应的文件拷贝到相应的目录下，比如我们向系统中新加一个应用程序。可以将新增的应用拷贝到我们新建的update/system/app/下（system目录是事先拷贝编译源码后生成的system目录），打包并签名后，拷贝到SD卡就可以使用了。这种方式在实际的tcc8800开发板中未测试成功。签名部分未通过，可能与具体的开发板相关。
& & & & &&第二种制作方式：命令制作。Android源码系统中为我们提供了制作update.zip刷机包的命令，即make otapackage。该命令在编译源码完成后并在源码根目录下执行。 具体操作方式：在源码根目录下执行
& & & & & & & & ①$ . build/envsetup.sh。&
& & & & & & & & ②$ lunch 然后选择你需要的配置(如17)。
& & & & & & & & ③$ make otapackage。
& & & & & 在编译完源码后最好再执行一遍上面的①、②步防止执行③时出现未找到对应规则的错误提示。命令执行完成后生成的升级包所在位置在out/target/product/full_tcc8800_evm_target_files-eng.mumu.059.zip将这个包重新命名为update.zip，并拷贝到SD卡中即可使用。
& & & & & &这种方式(即完全升级)在tcc8800开发板中已测试成功。
& & & &2) 使用make otapackage命令生成update.zip的过程分析。
& & & & & & 在源码根目录下执行make otapackage命令生成update.zip包主要分为两步，第一步是根据Makefile执行编译生成一个update原包（zip格式）。第二步是运行一个python脚本，并以上一步准备的zip包作为输入，最终生成我们需要的升级包。下面进一步分析这两个过程。
& & & & & &&第一步：编译Makefile。对应的Makefile文件所在位置：build/core/Makefile。从该文件的884行（tcc8800,gingerbread0919）开始会生成一个zip包，这个包最后会用来制作OTA package 或者filesystem image。先将这部分的对应的Makefile贴出来如下：
# -----------------------------------------------------------------
# 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,updater)/updater
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_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_ANDROID_INFO_TXT_TARGET) \
$(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)
@# 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
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
ifdef BOARD_SYSTEMIMAGE_PARTITION_SIZE
$(hide) echo &system_size=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE)& && $(zip_root)/META/misc_info.txt
ifdef BOARD_USERDATAIMAGE_PARTITION_SIZE
$(hide) echo &userdata_size=$(BOARD_USERDATAIMAGE_PARTITION_SIZE)& && $(zip_root)/META/misc_info.txt
$(hide) echo &tool_extensions=$(tool_extensions)& && $(zip_root)/META/misc_info.txt
ifdef mkyaffs2_extra_flags
$(hide) echo &mkyaffs2_extra_flags=$(mkyaffs2_extra_flags)& && $(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 files in the zip, and save the output
$(hide) zipinfo -1 $@ | awk -F/ 'BEGIN { OFS=&/& } /^SYSTEM\// {$$1 = &system&; print}' | $(HOST_OUT_EXECUTABLES)/fs_config & $(zip_root)/META/filesystem_config.txt
$(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/filesystem_config.txt)
target-files-package: $(BUILT_TARGET_FILES_PACKAGE)
ifneq ($(TARGET_SIMULATOR),true)
ifneq ($(TARGET_PRODUCT),sdk)
ifneq ($(TARGET_DEVICE),generic)
ifneq ($(TARGET_NO_KERNEL),true)
ifneq ($(recovery_fstab),)
& & & & & & 根据上面的Makefile可以分析这个包的生成过程：
& & & & & & 首先创建一个root_zip根目录，并依次在此目录下创建所需要的如下其他目录
& & & & & & ①创建RECOVERY目录，并填充该目录的内容，包括kernel的镜像和recovery根文件系统的镜像。此目录最终用于生成recovery.img。
& & & & & & ②创建并填充BOOT目录。包含kernel和cmdline以及pagesize大小等，该目录最终用来生成boot.img。
& & & & & & ③向SYSTEM目录填充system image。
& & & & & & ④向DATA填充data image。
& & & & & & ⑤用于生成OTA package包所需要的额外的内容。主要包括一些bin命令。
& & & & & & ⑥创建META目录并向该目录下添加一些文本文件，如apkcerts.txt(描述apk文件用到的认证证书)，misc_info.txt(描述Flash内存的块大小以及boot、recovery、system、userdata等分区的大小信息)。
& & & & & & ⑦使用保留连接选项压缩我们在上面获得的root_zip目录。
& & & & & & ⑧使用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升级包的过程。
& & & & & & & & & &㈠ 首先看一下这个脚本开始部分的帮助文档。代码如下：
#!/usr/bin/env python
# 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.
(--package_key)
Key to use to sign the package (default is
&build/target/product/security/testkey&).
(--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.
& & & & & & & & & & & & 下面简单翻译一下他们的使用方法以及选项的作用。
& & & & & & & & & & & & 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包的。先讲这个脚本的代码贴出来如下：
import sys
if sys.hexversion & 0x:
print && sys.stderr, &Python 2.4 or newer is required.&
sys.exit(1)
import copy
import errno
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 = 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
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.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):
# See if the target_files contains a record of what the uid,
# gid, and mode is supposed to be.
output = input_zip.read(&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.
p = common.Run([&fs_config&], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
suffix = { False: &&, True: &/& }
input = &&.join([&%s%s\n& % (i.name, suffix[i.dir])
for i in cls.ITEMS.itervalues() if i.name])
output, error = p.communicate(input)
assert not error
for line in output.split(&\n&):
if not line: continue
name, uid, gid, mode = line.split()
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.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 = 0, 0, 0644
i = cls.ITEMS.get(&system/etc/install-recovery.sh&, 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
Recursively calls itself for all descendants.
Returns a dict of {(uid, gid, dmode, fmode): 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) tuple that will match the most descendants of that
assert self.dir
d = self.descendants = {(self.uid, self.gid, self.mode, None): 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)
d[k] = d.get(k, 0) + 1
# Find the (uid, gid, dmode, fmode) 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 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])
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.
# 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]:
script.SetPermissions(&/&+item.name, item.uid, item.gid, item.mode)
for i in item.children:
recurse(i, current)
if item.uid != current[0] or item.gid != current[1] or \
item.mode != current[3]:
script.SetPermissions(&/&+item.name, 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
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, input_zip):
device = GetBuildProp(&ro.product.device&, input_zip)
script.AssertDevice(device)
def MakeRecoveryPatch(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.
Returns an Item for the shell script, which must be made
executable.
d = 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&, _dict)
recovery_type, recovery_device = common.GetTypeAndDevice(&/recovery&, _dict)
# Images with different content will have a 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(recovery_img.data[: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
log -t recovery &Recovery image already installed&
&&& % { '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/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&, input_zip),
&pre-device&: GetBuildProp(&ro.product.device&, input_zip),
&post-timestamp&: GetBuildProp(&ro.build.date.utc&, input_zip),
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&, 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.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 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):
fn = &system/& + info.filename[7:]
data = z.read(info.filename)
out[fn] = common.File(fn, data)
return out
def GetBuildProp(property, z):
&&&Return the fingerprint of the build of a given target-files
ZipFile object.&&&
bp = z.read(&SYSTEM/build.prop&)
if not property:
m = re.search(re.escape(property) + r&=(.*)\n&, bp)
raise common.ExternalError(&couldn't find %s in build.prop& % (property,))
return m.group(1).strip()
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, _dict)
metadata = {&pre-device&: GetBuildProp(&ro.product.device&, source_zip),
&post-timestamp&: GetBuildProp(&ro.build.date.utc&, 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)
print &Loading target...&
target_data = LoadSystemFiles(target_zip)
print &Loading source...&
source_data = LoadSystemFiles(source_zip)
verbatim_targets = []
patch_list = []
diffs = []
largest_source_size = 0
for fn in sorted(target_data.keys()):
tf = target_data[fn]
assert fn == tf.name
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:
# F consider sending as a patch
diffs.append(common.Difference(tf, sf))
# Target file identical to source.
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/& + tf.name + &.p&, d)
patch_list.append((tf.name, tf, sf, tf.size, sha.sha(d).hexdigest()))
largest_source_size = max(largest_source_size, sf.size)
source_fp = GetBuildProp(&ro.build.fingerprint&, source_zip)
target_fp = GetBuildProp(&ro.build.fingerprint&, 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_boot.data != target_boot.data)
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 = (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, 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 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 ----&)
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] +
[&/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...&)
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 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:
# Is it better to generate recovery as a patch from the current
# boot image, or from the previous recovery image?
# 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.
# complicated schemes may let us effectively use both.
# A 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/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&)
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:
scirpt.AppendExtra(OPTIONS.extra_script)
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 (&--worker_threads&):
OPTIONS.worker_threads = int(a)
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&)
_dict = common.LoadInfoDict(input_zip)
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
if OPTIONS.package_key:
temp_zip_file = tempfile.NamedTemporaryFile()
output_zip = zipfile.ZipFile(temp_zip_file, &w&,
compression=zipfile.ZIP_DEFLATED)
output_zip = zipfile.ZipFile(args[1], &w&,
compression=zipfile.ZIP_DEFLATED)
if OPTIONS.incremental_source is None:
WriteFullOTAPackage(input_zip, output_zip)
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 = _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(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)
& & & & & & & & & & & &主函数main是python的入口函数，我们从main函数开始看，大概看一下main函数（脚本最后）里的流程就能知道脚本的执行过程了。
& & & & & & & & & & & &① 在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/full_tcc8800_evm-ota-eng.mumu.326.zip。将升级包拷贝到SD卡中就可以用来升级了。
四、&Android OTA增量包update.zip的生成
& & & & &在上面的过程中生成的update.zip升级包是全部系统的升级包。大小有80M多。这对手机用户来说，用来升级的流量是很大的。而且在实际升级中，我们只希望能够升级我们改变的那部分内容。这就需要使用增量包来升级。生成增量包的过程也需要上文中提到的ota_from_target_files.py的参与。
& & & & &下面是制作update.zip增量包的过程。
& & & & & ① 在源码根目录下依次执行下列命令
& & & & & &$ . build/envsetup.sh
& & & & & &$ lunch 选择17
& & & & & &$ make
& & & & & &$ make otapackage
& & & & & &执行上面的命令后会在out/target/product/tcc8800/下生成我们第一个系统升级包。我们先将其命名为A.zip
& & & & & ② 在源码中修改我们需要改变的部分，比如修改内核配置，增加新的驱动等等。修改后再一次执行上面的命令。就会生成第二个我们修改后生成的update.zip升级包。将 &其命名为B.zip。
& & & & & ③ 在上文中我们看了ota_from_target_files.py脚本的使用帮助，其中选项-i就是用来生成差分增量包的。使用方法是以上面的A.zip 和B.zip包作为输入，以update.zip包作 &为输出。生成的update.zip就是我们最后需要的增量包。
& & & & & & & 具体使用方式是：将上述两个包拷贝到源码根目录下，然后执行下面的命令。
& & & & & & & $ ./build/tools/releasetools/ota_from_target_files -i A.zip B.zip update.zip。
& & & & & & & 在执行上述命令时会出现未找到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和B.zip，并拷贝到SD卡根目录下重复执行上面的命令：
& & & & & & & &$ ./build/tools/releasetools/ota_form_target_files -i A.zip B.zip update.zip。
& & & & & & & 在上述命令即将执行完毕时，在device/telechips/common/releasetools.py会调用IncrementalOTA_InstallEnd,在这个函数中读取包中的RADIO/bootloader.img。
& & & & & & & 而包中是没有这个目录和bootloader.img的。所以执行失败，未能生成对应的update.zip。可能与我们未修改bootloader（升级firmware）有关。此问题在下一篇博客已经解决。
& & & & & &&&在下一篇中讲解制作增量包失败的原因，以及解决方案。
-------------------------------------------
& & & & & & & & & & &&Android系统Recovery工作原理之使用update.zip升级过程分析（二）---update.zip差分包问题的解决
& & & &在上一篇末尾提到的生成差分包时出现的问题，现已解决，由于最近比较忙，相隔的时间也比较长，所以单列一个篇幅提示大家。这个问题居然是源码中的问题，可能你已经制作成功了，不过我的这个问题确实是源码中的一个问题，不知道是不是一个bug，下文会具体分析！
一、生成OTA增量包失败的解决方案
& & & & & &在上一篇中末尾使用ota_from_target_files脚本制作update.zip增量包时失败，我们先将出现的错误贴出来。
& & & & & & & & &
& & & & & & &&在执行这个脚本的最后读取input_zip中RADIO/bootloader.img时出现错误，显示DeviceSpecifiParams这个对象中没有input_zip属性。
& & & & &我们先从脚本中出现错误的调用函数中开始查找。出现错误的调用地方是在函WriteIncrementalOTAPackage（443行）中的device_specific.IncrementalOTA_InstallEnd()，其位于WriteIncrementalOTAPackage()中的末尾。进一步跟踪源码发现，这是一个回调函数，他的具体执行方法位于源码中/device/telechips/common/releasetools.py脚本中的IncrementalOTA_InstallEnd()函数。下面就分析这个函数的作用。
& & & & & releasetools.py脚本中的两个函数FullOTA_InstallEnd()和IncrementalOTA_InstallEnd()的作用都是从输入包中读取RADIO/下的bootloader.img文件写到输出包中，同时生成安装bootloader.img时执行脚本的那部分命令。只不过一个是直接将输入包中的bootloader.img镜像写到输出包中，一个是先比较target_zip和source_zip中的bootloader.img是否不同（使用选项-i生成差分包时），然后将新的镜像写入输出包中。下面先将这个函数(位于/device/telechips/common/releasetools.py)的具体实现贴出来：
& & & & & & & & & &&
& & & & & & & &我们的实际情况是，在用命令make otapackage时生成的包中是没有这个RADIO目录下的bootloader.img镜像文件（因为这部分更新已被屏蔽掉了）。但是这个函数中对于从包中未读取到bootloader.img文件的情况是有错误处理的，即返回。所以我们要从&&出现的实际错误中寻找问题的原由。
& & & & &真正出现错误的地方是：
& & & & & target_bootloader=info.input_zip.read(“RADIO/bootloader.img”)。
& & & & &出现错误的原因是：AttributeError：‘DeviceSpecificParams’object has no attribute &‘input_zip’，提示我们DeviceSpecificParams对象没有input_zip这个属性。
& & & & &在用ota_from_target_files脚本制作差分包时使用了选项-i，并且只有这种情况有三个参数，即target_zip 、source_zip、 out_zip。而出现错误的地方是target_bootloader=info.input_zip_read(“RADIO/bootloader.img”)，它使用的是input_zip，我们要怀疑这个地方是不是使用错了，而应该使用info.target_zip.read()。下面可以证实一下我们的猜测。
& & & & &从ota_from_target_files脚本中WriteFullOTAPackage()和WriteIncrementalOTAPackage这两个函数（分别用来生成全包和差分包）可以发现，在他们的开始部分都对device_specific进行了赋值。其中WriteFullOTAPackage()对应的参数是input_zip和out_zip，而WriteIncrementalOTAPackage对应的是target_zip,source_zip,out_zip，我们可以看一下在WriteIncrementalOTAPackage函数中这部分的具体实现：
& & & & & & & & &&
& & &&& & & 从上图可以发现，在WriteIncrementalOTAPackage函数对DeviceSpecificParams对象进行初始化时确实使用的是target_zip而不是input_zip。而在releasetools.py脚本中使用的却是info.input_zip.read()，所以才会出现DeviceSpecificParams对象没有input_zip这个属性。由此我们找到了问题的所在(这是不是源码中的一个Bug？)。
& & & & 将releasetools.py脚本IncrementalOTA_InstallEnd(info)函数中的 target_bootloader=info.input_zip.
read(“RADIO/bootloader.img”)为：target_bootloader=info.target_zip.read(“RADIO/bootloader.img”)，然后重新执行上面提到的制作差分包命令。就生成了我们需要的差分包update.zip。
二、&&&&&&&&&&差分包update.zip的更新测试& & &
& & & & & & & &&在上面制作差分包脚本命令中，生成差分包的原理是，参照第一个参数（target_zip），将第二个参数（source_zip）中不同的部分输出到第三个参数（output_zip）中。其中target_zip与source_zip的先后顺序不同，产生的差分包也将不同。
& & & & & 在实际的测试过程中，我们的增量包要删除之前添加的一个应用（在使用update.zip全包升级时增加的），其他的部分如内核都没有改动，所以生成的差分包很简单，只有META-INF这个文件夹。主要的不同都体现在updater-script脚本中，其中的#----start make changes& here----之后的部分就是做出改变的部分，最主要的脚本命令是：&delete(“/system/app/CheckUpdateAll.apk”
, “/system/recovery.img”);在具体更新时它将删除CheckUpdateAll.apk这个应用。
& & & & & 为了大家参考，还是把这个差分包的升级脚本贴出来，其对应的完全升级的脚本在第九篇已贴出：
mount(&yaffs2&, &MTD&, &system&, &/system&);
assert(file_getprop(&/system/build.prop&, &ro.build.fingerprint&) == &telechips/full_tcc8800_evm/tcc.5/GRJ90/eng.mumu.232:eng/test-keys& ||
file_getprop(&/system/build.prop&, &ro.build.fingerprint&) == &telechips/full_tcc8800_evm/tcc.5/GRJ90/eng.mumu.232:eng/test-keys&);
assert(getprop(&ro.product.device&) == &tcc8800& ||
getprop(&ro.build.product&) == &tcc8800&);
ui_print(&Verifying current system...&);
show_progress(0.);
# ---- start making changes here ----
ui_print(&Removing unneeded files...&);
delete(&/system/app/CheckUpdateAll.apk&,
&/system/recovery.img&);
show_progress(0.);
ui_print(&Patching system files...&);
show_progress(0.);
ui_print(&Symlinks and permissions...&);
set_perm_recursive(0, 0, , &/system&);
set_perm_recursive(0, , 0755, &/system/bin&);
set_perm(0, , &/system/bin/netcfg&);
set_perm(0, , &/system/bin/ping&);
set_perm(0, , &/system/bin/run-as&);
set_perm_recursive(, , &/system/etc/bluetooth&);
set_perm(0, 0, 0755, &/s}