bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    CCDirector *pDirector = CCDirector::sharedDirector();
    pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());
    pDirector->setProjection(kCCDirectorProjection2D);

    // set FPS. the default value is 1.0/60 if you don't call this
    pDirector->setAnimationInterval(1.0 / 60);

    // register lua engine
    CCLuaEngine *pEngine = CCLuaEngine::defaultEngine();
    CCScriptEngineManager::sharedManager()->setScriptEngine(pEngine);

    CCLuaStack *pStack = pEngine->getLuaStack();

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
    // load framework
    pStack->loadChunksFromZIP("res/framework_precompiled.zip");

    // set script path
    string path = CCFileUtils::sharedFileUtils()->fullPathForFilename("scripts/main.lua");
    ......

void Updater::Helper::handlerState(Message *msg)
{
    StateMessage* stateMsg = (StateMessage*)msg->obj;
    if(stateMsg->manager->_delegate)
    {
        stateMsg->manager->_delegate->onState(stateMsg->code);
    }
    if (stateMsg->manager->_scriptHandler)
    {
        std::string stateMessage;
        switch ((StateCode)stateMsg->code)
        {
            case kDownStart:
                stateMessage = "downloadStart";
                break;

            case kDownDone:
                stateMessage = "downloadDone";
                break;

            case kUncompressStart:
                stateMessage = "uncompressStart";
                break;
            case kUncompressDone:
                stateMessage = "uncompressDone";
                break;

            default:
                stateMessage = "stateUnknown";
        }

        CCScriptEngineManager::sharedManager()
            ->getScriptEngine()
            ->executeEvent(
                           stateMsg->manager->_scriptHandler,
                           "state",
                           CCString::create(stateMessage.c_str()),
                           "CCString");
    }

    delete ((StateMessage*)msg->obj);
}

function us._updateHandler(event, value)
    updater.state = event
    if event == "success" then
        updater.stateValue = value:getCString()
        -- 成功之后更新资源列表，合并新资源
        updater.updateFinalResInfo()
        -- 调用成功后的处理函数
        if us._succHandler then
            us._succHandler()
        end
    elseif event == "error" then
        updater.stateValue = value:getCString()
    elseif event == "progress" then
        updater.stateValue = tostring(value:getValue())
    elseif event == "state" then
        updater.stateValue = value:getCString()
    end
    -- us._label 是一个CCLabelTTF，用来显示进度和状态
    us._label:setString(updater.stateValue)
    assert(event ~= "error", 
        string.format("Update error: %s !", updater.stateValue))
end

updater:registerScriptHandler(us._updateHandler)

bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    CCDirector *pDirector = CCDirector::sharedDirector();
    pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());
    pDirector->setProjection(kCCDirectorProjection2D);

    // set FPS. the default value is 1.0/60 if you don't call this
    pDirector->setAnimationInterval(1.0 / 60);

    // register lua engine
    CCLuaEngine *pEngine = CCLuaEngine::defaultEngine();
    CCScriptEngineManager::sharedManager()->setScriptEngine(pEngine);

    CCLuaStack *pStack = pEngine->getLuaStack();

    string gtrackback = "\
    function __G__TRACKBACK__(errorMessage) \
    print(\"----------------------------------------\") \
    print(\"LUA ERROR: \" .. tostring(errorMessage) .. \"\\n\") \
    print(debug.traceback(\"\",2)) \
    print(\"----------------------------------------\") \
    end";
    pEngine->executeString(gtrackback.c_str());

    // load update framework
    pStack->loadChunksFromZIP("res/lib/update.zip");

    string start_path = "require(\"update.UpdateApp\").new(\"update\"):run(true)";
    CCLOG("------------------------------------------------");
    CCLOG("EXECUTE LUA STRING: %s", start_path.c_str());
    CCLOG("------------------------------------------------");
    pEngine->executeString(start_path.c_str());

    return true;
}

require("update.UpdateApp").new("update"):run(true); 

--- The entry of Game
-- @author zrong(zengrong.net)
-- Creation 2014-07-03

local UpdateApp = {}

UpdateApp.__cname = "UpdateApp"
UpdateApp.__index = UpdateApp
UpdateApp.__ctype = 2

local sharedDirector = CCDirector:sharedDirector()
local sharedFileUtils = CCFileUtils:sharedFileUtils()
local updater = require("update.updater")

function UpdateApp.new(...)
    local instance = setMetatable({}, UpdateApp)
    instance.class = UpdateApp
    instance:ctor(...)
    return instance
end

function UpdateApp:ctor(appName, packageRoot)
    self.name = appName
    self.packageRoot = packageRoot or appName

    print(string.format("UpdateApp.ctor,appName:%s,packageRoot:%s", appName, packageRoot))

    -- set global app
    _G[self.name] = self
end

function UpdateApp:run(checkNewUpdatePackage)
    --print("I am new update package")
    local newUpdatePackage = updater.hasNewUpdatePackage()
    print(string.format("UpdateApp.run(%s),newUpdatePackage:%s", 
        checkNewUpdatePackage, newUpdatePackage))
    if  checkNewUpdatePackage and newUpdatePackage then
        self:updateSelf(newUpdatePackage)
    elseif updater.checkUpdate() then
        self:runUpdateScene(function()
            _G["finalRes"] = updater.getResCopy()
            self:runRootScene()
        end)
    else
        _G["finalRes"] = updater.getResCopy()
        self:runRootScene()
    end
end

-- Remove update package,load new update package and run it.
function UpdateApp:updateSelf(newUpdatePackage)
    print("UpdateApp.updateSelf ", newUpdatePackage)
    local updatePackage = {
        "update.UpdateApp",
        "update.updater",
        "update.updateScene",
    }
    self:_printPackages("--before clean")
    for __,v in ipairs(updatePackage) do
        package.preload[v] = nil
        package.loaded[v] = nil
    end
    self:_printPackages("--after clean")
    _G["update"] = nil
    CCLuaLoadChunksFromZIP(newUpdatePackage)
    self:_printPackages("--after CCLuaLoadChunksForZIP")
    require("update.UpdateApp").new("update"):run(false)
    self:_printPackages("--after require and run")
end

-- Show a scene for update.
function UpdateApp:runUpdateScene(handler)
    self:enterScene(require("update.updateScene").addListener(handler))
end

-- Load all of packages(except update package,it is not in finalRes.lib)
-- and run root app.
function UpdateApp:runRootScene()
    for __, v in pairs(finalRes.lib) do
        print("runRootScene:CCLuaLoadChunksFromZip",__, v)
        CCLuaLoadChunksFromZIP(v)
    end

    require("root.RootScene").new("root"):run()
end

function UpdateApp:_printPackages(label)
    label = label or ""
    print("\npring packages "..label.."------------------")
    for __k, __v in pairs(package.preload) do
        print("package.preload:", __k, __v)
    end
    for __k, __v in pairs(package.loaded) do
        print("package.loaded:", __v)
    end
    print("print packages "..label.."------------------\n")
end


function UpdateApp:exit()
    sharedDirector:endToLua()
    os.exit()
end

function UpdateApp:enterScene(__scene)
    if sharedDirector:getRunningScene() then
        sharedDirector:replaceScene(__scene)
    else
        sharedDirector:runWithScene(__scene)
    end
end

return UpdateApp

_G["finalRes"] = updater.getResCopy()

local updatePackage = {
    "update.UpdateApp",
    "update.updater",
    "update.updateScene",
}
for __,v in ipairs(updatePackage) do
    package.preload[v] = nil
    package.loaded[v] = nil
end
_G["update"] = nil
CCLuaLoadChunksFromZIP(newUpdatePackage)
require("update.UpdateApp").new("update"):run(false)

for __, v in pairs(finalRes.lib) do
    print("runRootScene:CCLuaLoadChunksFromZip", v)
    CCLuaLoadChunksFromZIP(v)
end

require("root.RootScene").new("root"):run()

------
-- updateScene for update package.
-- This is a object,not a class.
-- In this scene,it will show download progress bar 
-- and state for uncompress.
-- @author zrong(zengrong.net)
-- Creation: 2014-07-03

local updater = require("update.updater")
local sharedDirector         = CCDirector:sharedDirector()

-- check device screen size
local glview = sharedDirector:getOpenGLView()
local size = glview:getFrameSize()
local display = {}
display.sizeInPixels = {width = size.width, height = size.height}

local w = display.sizeInPixels.width
local h = display.sizeInPixels.height

CONFIG_SCREEN_WIDTH = 1280 
CONFIG_SCREEN_HEIGHT = 800
CONFIG_SCREEN_AUTOSCALE = "FIXED_HEIGHT"

local scale, scaleX, scaleY

scaleX, scaleY = w / CONFIG_SCREEN_WIDTH, h / CONFIG_SCREEN_HEIGHT
scale = scaleY
CONFIG_SCREEN_WIDTH = w / scale

glview:setDesignResolutionSize(CONFIG_SCREEN_WIDTH, CONFIG_SCREEN_HEIGHT, kResolutionNoBorder)

local winSize = sharedDirector:getWinSize()
display.contentScaleFactor = scale
display.size               = {width = winSize.width, height = winSize.height}
display.width              = display.size.width
display.height             = display.size.height
display.cx                 = display.width / 2
display.cy                 = display.height / 2
display.c_left             = -display.width / 2
display.c_right            = display.width / 2
display.c_top              = display.height / 2
display.c_bottom           = -display.height / 2
display.left               = 0
display.right              = display.width
display.top                = display.height
display.bottom             = 0
display.widthInPixels      = display.sizeInPixels.width
display.heightInPixels     = display.sizeInPixels.height

print("# display in updateScene start")
print(string.format("# us.CONFIG_SCREEN_AUTOSCALE      = %s", CONFIG_SCREEN_AUTOSCALE))
print(string.format("# us.CONFIG_SCREEN_WIDTH          = %0.2f", CONFIG_SCREEN_WIDTH))
print(string.format("# us.CONFIG_SCREEN_HEIGHT         = %0.2f", CONFIG_SCREEN_HEIGHT))
print(string.format("# us.display.widthInPixels        = %0.2f", display.widthInPixels))
print(string.format("# us.display.heightInPixels       = %0.2f", display.heightInPixels))
print(string.format("# us.display.contentScaleFactor   = %0.2f", display.contentScaleFactor))
print(string.format("# us.display.width                = %0.2f", display.width))
print(string.format("# us.display.height               = %0.2f", display.height))
print(string.format("# us.display.cx                   = %0.2f", display.cx))
print(string.format("# us.display.cy                   = %0.2f", display.cy))
print(string.format("# us.display.left                 = %0.2f", display.left))
print(string.format("# us.display.right                = %0.2f", display.right))
print(string.format("# us.display.top                  = %0.2f", display.top))
print(string.format("# us.display.bottom               = %0.2f", display.bottom))
print(string.format("# us.display.c_left               = %0.2f", display.c_left))
print(string.format("# us.display.c_right              = %0.2f", display.c_right))
print(string.format("# us.display.c_top                = %0.2f", display.c_top))
print(string.format("# us.display.c_bottom             = %0.2f", display.c_bottom))
print("# display in updateScene done")

display.ANCHOR_POINTS = {
    CCPoint(0.5, 0.5),  -- CENTER
    CCPoint(0, 1),      -- TOP_LEFT
    CCPoint(0.5,    -- TOP_CENTER
    CCPoint(1,      -- TOP_RIGHT
    CCPoint(0,    -- CENTER_LEFT
    CCPoint(1,    -- CENTER_RIGHT
    CCPoint(0, 0),      -- BOTTOM_LEFT
    CCPoint(1,      -- BOTTOM_RIGHT
    CCPoint(0.5,    -- BOTTOM_CENTER
}

display.CENTER        = 1
display.LEFT_TOP      = 2; display.TOP_LEFT      = 2
display.CENTER_TOP    = 3; display.TOP_CENTER    = 3
display.RIGHT_TOP     = 4; display.TOP_RIGHT     = 4
display.CENTER_LEFT   = 5; display.LEFT_CENTER   = 5
display.CENTER_RIGHT  = 6; display.RIGHT_CENTER  = 6
display.BOTTOM_LEFT   = 7; display.LEFT_BOTTOM   = 7
display.BOTTOM_RIGHT  = 8; display.RIGHT_BOTTOM  = 8
display.BOTTOM_CENTER = 9; display.CENTER_BOTTOM = 9

function display.align(target, anchorPoint, x, y)
    target:setAnchorPoint(display.ANCHOR_POINTS[anchorPoint])
    if x and y then target:setPosition(x, y) end
end

local us = CCScene:create()
us.name = "updateScene"

local localResInfo = nil

function us._addUI()
    -- Get the newest resinfo in ures.
    local localResInfo = updater.getResCopy()

    local __bg = CCSprite:create(us._getres("res/pic/init_bg.png"))
    display.align(__bg, display.CENTER, display.cx, display.cy)
    us:addChild(__bg, 0)

    local __label = CCLabelTTF:create("Loading...", "Arial", 24)
    __label:setColor(ccc3(255, 0, 0))
    us._label = __label
    display.align(__label, display.bottom+30)
    us:addChild(__label, 10)
end

function us._getres(path)
    if not localResInfo then
        localResInfo = updater.getResCopy()
    end
    for key, value in pairs(localResInfo.oth) do
        print("us._getres:", key, value)
        local pathInIndex = string.find(key, path)
        if pathInIndex and pathInIndex >= 1 then
            print("us._getres getvalue:", path)
            res[path] = value
            return value
        end
    end
    return path
end

function us._sceneHandler(event)
    if event == "enter" then
        print(string.format("updateScene \"%s:onEnter()\"", us.name))
        us.onEnter()
    elseif event == "cleanup" then
        print(string.format("updateScene \"%s:onCleanup()\"", us.name))
        us.onCleanup()
    elseif event == "exit" then
        print(string.format("updateScene \"%s:onExit()\"", us.name))
        us.onExit()

        if DEBUG_MEM then
            print("----------------------------------------")
            print(string.format("LUA VM MEMORY USED: %0.2f KB", collectgarbage("count")))
            CCTextureCache:sharedTextureCache():dumpCachedTextureInfo()
            print("----------------------------------------")
        end
    end
end

function us._updateHandler(event, value)
    updater.state = event
    if event == "success" then
        updater.stateValue = value:getCString()
        updater.updateFinalResInfo()
        if us._succHandler then
            us._succHandler()
        end
    elseif event == "error" then
        updater.stateValue = value:getCString()
    elseif event == "progress" then
        updater.stateValue = tostring(value:getValue())
    elseif event == "state" then
        updater.stateValue = value:getCString()
    end
    us._label:setString(updater.stateValue)
    assert(event ~= "error", updater.stateValue))
end

function us.addListener(handler)
    us._succHandler = handler
    return us
end

function us.onEnter()
    updater.update(us._updateHandler)
end

function us.onExit()
    updater.clean()
    us:unregisterScriptHandler()
end

function us.onCleanup()
end

us:registerScriptHandler(us._sceneHandler)
us._addUI()
return us

display.newSprite("res/pic/init_bg.png")
    :align(display.CENTER, display.cy)
    :addTo(self, 0)
 ```

在没有quick framework的时候需要改成这样：

``` lua
local __bg = CCSprite:create(us._getres("res/pic/init_bg.png"))
display.align(__bg, display.cy)
us:addChild(__bg, 0)

--- The helper for update package.
-- It can download resources and uncompress it,
-- copy new package to res directory,
-- and remove temporery directory.
-- @author zrong(zengrong.net)
-- Creation 2014-07-03

require "lfs"
local updater = {}
updater.STATES = {
    kDownStart = "downloadStart",
    kDownDone = "downloadDone",
    kUncompressStart = "uncompressStart",
    kUncompressDone = "uncompressDone",
    unknown = "stateUnknown",
}

updater.ERRORS = {
    kCreateFile = "errorCreateFile",
    kNetwork = "errorNetwork",
    kNoNewVersion = "errorNoNewVersion",
    kUncompress = "errorUncompress",
    unknown = "errorUnknown";
}

function updater.isState(state)
    for k,v in pairs(updater.STATES) do
        if v == state then
            return true
        end
    end
    return false
end

function updater.clone(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for key, value in pairs(object) do
            new_table[_copy(key)] = _copy(value)
        end
        return setMetatable(new_table, getMetatable(object))
    end
    return _copy(object)
end

function updater.vardump(object, label, returnTable)
    local lookupTable = {}
    local result = {}

    local function _v(v)
        if type(v) == "string" then
            v = "\"" .. v .. "\""
        end
        return tostring(v)
    end

    local function _vardump(object, indent, nest)
        label = label or ""
        local postfix = ""
        if nest > 1 then postfix = "," end
        if type(object) ~= "table" then
            if type(label) == "string" then
                result[#result +1] = string.format("%s[\"%s\"] = %s%s", _v(object), postfix)
            else
                result[#result +1] = string.format("%s%s%s", postfix)
            end
        elseif not lookupTable[object] then
            lookupTable[object] = true

            if type(label) == "string" then
                result[#result +1 ] = string.format("%s%s = {", label)
            else
                result[#result +1 ] = string.format("%s{", indent)
            end
            local indent2 = indent .. "    "
            local keys = {}
            local values = {}
            for k, v in pairs(object) do
                keys[#keys + 1] = k
                values[k] = v
            end
            table.sort(keys, function(a, b)
                if type(a) == "number" and type(b) == "number" then
                    return a < b
                else
                    return tostring(a) < tostring(b)
                end
            end)
            for i, k in ipairs(keys) do
                _vardump(values[k], k, indent2, nest + 1)
            end
            result[#result +1] = string.format("%s}%s", postfix)
        end
    end
    _vardump(object, "", 1)

    if returnTable then return result end
    return table.concat(result, "\n")
end

local u  = nil
local f = CCFileUtils:sharedFileUtils()
-- The res index file in original package.
local lresinfo = "res/resinfo.lua"
local uroot = f:getWritablePath()
-- The directory for save updated files.
local ures = uroot.."res/"
-- The package zip file what download from server.
local uzip = uroot.."res.zip"
-- The directory for uncompress res.zip.
local utmp = uroot.."utmp/"
-- The res index file in zip package for update.
local zresinfo = utmp.."res/resinfo.lua"

-- The res index file for final game.
-- It combiled original lresinfo and zresinfo.
local uresinfo = ures .. "resinfo.lua"

local localResInfo = nil
local remoteResInfo = nil
local finalResInfo = nil

local function _initUpdater()
    print("initUpdater,", u)
    if not u then u = Updater:new() end
    print("after initUpdater:", u)
end

function updater.writeFile(path, content, mode)
    mode = mode or "w+b"
    local file = io.open(path, mode)
    if file then
        if file:write(content) == nil then return false end
        io.close(file)
        return true
    else
        return false
    end
end

function updater.readFile(path)
    return f:getFileData(path)
end

function updater.exists(path)
    return f:isFileExist(path)
end

--[[
-- Departed,uses lfs instead.
function updater._mkdir(path)
    _initUpdater()
    return u:createDirectory(path)
end

-- Departed,get a warning in ios simulator
function updater._rmdir(path)
    _initUpdater()
    return u:removeDirectory(path)
end
--]]

function updater.mkdir(path)
    if not updater.exists(path) then
        return lfs.mkdir(path)
    end
    return true
end

function updater.rmdir(path)
    print("updater.rmdir:", path)
    if updater.exists(path) then
        local function _rmdir(path)
            local iter, dir_obj = lfs.dir(path)
            while true do
                local dir = iter(dir_obj)
                if dir == nil then break end
                if dir ~= "." and dir ~= ".." then
                    local curDir = path..dir
                    local mode = lfs.attributes(curDir, "mode") 
                    if mode == "directory" then
                        _rmdir(curDir.."/")
                    elseif mode == "file" then
                        os.remove(curDir)
                    end
                end
            end
            local succ, des = os.remove(path)
            if des then print(des) end
            return succ
        end
        _rmdir(path)
    end
    return true
end

-- Is there a update.zip package in ures directory?
-- If it is true,return its abstract path.
function updater.hasNewUpdatePackage()
    local newUpdater = ures.."lib/update.zip"
    if updater.exists(newUpdater) then
        return newUpdater
    end
    return nil
end

-- Check local resinfo and remote resinfo,compare their version value.
function updater.checkUpdate()
    localResInfo = updater.getLocalResInfo()
    local localVer = localResInfo.version
    print("localVer:", localVer)
    remoteResInfo = updater.getRemoteResInfo(localResInfo.update_url)
    local remoteVer = remoteResInfo.version
    print("remoteVer:", remoteVer)
    return remoteVer ~= localVer
end

-- Copy resinfo.lua from original package to update directory(ures) 
-- when it is not in ures.
function updater.getLocalResInfo()
    print(string.format("updater.getLocalResInfo,lresinfo:%s,uresinfo:%s", 
        lresinfo,uresinfo))
    local resInfoTxt = nil
    if updater.exists(uresinfo) then
        resInfoTxt = updater.readFile(uresinfo)
    else
        assert(updater.mkdir(ures), ures.." create error!")
        local info = updater.readFile(lresinfo)
        print("localResInfo:", info)
        assert(info, string.format("Can not get the constent from %s!", lresinfo))
        updater.writeFile(uresinfo, info)
        resInfoTxt = info
    end
    return assert(loadstring(resInfoTxt))()
end

function updater.getRemoteResInfo(path)
    _initUpdater()
    print("updater.getRemoteResInfo:", path)
    local resInfoTxt = u:getUpdateInfo(path)
    print("resInfoTxt:", resInfoTxt)
    return assert(loadstring(resInfoTxt))()
end

function updater.update(handler)
    assert(remoteResInfo and remoteResInfo.package, "Can not get remoteResInfo!")
    print("updater.update:", remoteResInfo.package)
    if handler then
        u:registerScriptHandler(handler)
    end
    updater.rmdir(utmp)
    u:update(remoteResInfo.package, uzip, utmp, false)
end

function updater._copyNewFile(resInZip)
    -- Create nonexistent directory in update res.
    local i,j = 1,1
    while true do
        j = string.find(resInZip, "/", i)
        if j == nil then break end
        local dir = string.sub(resInZip, 1,j)
        -- Save created directory flag to a table because
        -- the io operation is too slow.
        if not updater._dirList[dir] then
            updater._dirList[dir] = true
            local fullUDir = uroot..dir
            updater.mkdir(fullUDir)
        end
        i = j+1
    end
    local fullFileInURes = uroot..resInZip
    local fullFileInUTmp = utmp..resInZip
    print(string.format('copy %s to %s', fullFileInUTmp, fullFileInURes))
    local zipFileContent = updater.readFile(fullFileInUTmp)
    if zipFileContent then
        updater.writeFile(fullFileInURes, zipFileContent)
        return fullFileInURes
    end
    return nil
end

function updater._copyNewFilesBatch(resType, resInfoInZip)
    local resList = resInfoInZip[resType]
    if not resList then return end
    local finalRes = finalResInfo[resType]
    for __,v in ipairs(resList) do
        local fullFileInURes = updater._copyNewFile(v)
        if fullFileInURes then
            -- Update key and file in the finalResInfo
            -- Ignores the update package because it has been in memory.
            if v ~= "res/lib/update.zip" then
                finalRes[v] = fullFileInURes
            end
        else
            print(string.format("updater ERROR,copy file %s.", v))
        end
    end
end

function updater.updateFinalResInfo()
    assert(localResInfo and remoteResInfo,
        "Perform updater.checkUpdate() first!")
    if not finalResInfo then
        finalResInfo = updater.clone(localResInfo)
    end
    --do return end
    local resInfoTxt = updater.readFile(zresinfo)
    local zipResInfo = assert(loadstring(resInfoTxt))()
    if zipResInfo["version"] then
        finalResInfo.version = zipResInfo["version"]
    end
    -- Save a dir list maked.
    updater._dirList = {}
    updater._copyNewFilesBatch("lib", zipResInfo)
    updater._copyNewFilesBatch("oth", zipResInfo)
    -- Clean dir list.
    updater._dirList = nil
    updater.rmdir(utmp)
    local dumpTable = updater.vardump(finalResInfo, "local data", true)
    dumpTable[#dumpTable+1] = "return data"
    if updater.writeFile(uresinfo, table.concat(dumpTable, "\n")) then
        return true
    end
    print(string.format("updater ERROR,write file %s.", uresinfo))
    return false
end

function updater.getResCopy()
    if finalResInfo then return updater.clone(finalResInfo) end
    return updater.clone(localResInfo)
end

function updater.clean()
    if u then
        u:unregisterScriptHandler()
        u:delete()
        u = nil
    end
    updater.rmdir(utmp)
    localResInfo = nil
    remoteResInfo = nil
    finalResInfo = nil
end

return updater

local data = {
    version = "1.0",
    update_url = "http://192.168.18.22:8080/updater/resinfo.lua",
    lib = {
        ["res/lib/config.zip"] = "res/lib/config.zip",
        ["res/lib/framework_precompiled.zip"] = "res/lib/framework_precompiled.zip",
        ["res/lib/root.zip"] = "res/lib/root.zip",
        ......
    },
    oth = {
        ["res/pic/init_bg.png"] = "res/pic/init_bg.png",
}
return data

local data = {
    version = "1.0",
    lib = {
        ["res/lib/cc.zip"] = "res/lib/cc.zip",
        ["res/lib/config.zip"] = "/Users/zrong/Library/Application Support/iPhone Simulator/7.1/Applications/2B46FAC0-C419-42B5-92B0-B06DD16E113B/Documents/res/lib/config.zip",
}
return data

local data = {
    version = "1.0.2",
    package = "http://192.168.18.22:8080/updater/res.zip",
}
return data

res/
res/resinfo.lua
res/lib/cc.zip
res/pic/init_bg.png
......

local data = {
    version = "1.0.2",
    lib = {
        "res/lib/cc.zip",
    oth = {
        "res/pic/init_bg",
}
return data

display.newSprite("pic/init_bg.png")

display.newSprite("init_bg.png")

CCFileUtils:sharedFileUtils:addSearchPath("res/")
CCFileUtils:sharedFileUtils:addSearchPath("res/pic/")

display.newSprite("res/pic/init_bg.png")

res = {}

function io.getres(path)
    print("io.getres originl:", path)
    if CCFileUtils:sharedFileUtils():isAbsolutePath(path) then
        return path
    end
    if res[path] then return res[path] end
    for key, value in pairs(finalRes.oth) do
        print(key, path)
        if pathInIndex and pathInIndex >= 1 then
            print("io.getres getvalue:", path)
            res[path] = value
            return value
        end
    end
    print("io.getres no get:", path)
    return path
end

if string.byte(filename) == 35 then -- first char is #
    local frame = display.newSpriteFrame(string.sub(filename, 2))
    if frame then
        sprite = spriteClass:createWithSpriteFrame(frame)
    end
else
    if display.TEXTURES_PIXEL_FORMAT[filename] then
        CCTexture2D:setDefaultAlphaPixelFormat(display.TEXTURES_PIXEL_FORMAT[filename])
        sprite = spriteClass:create(filename)
        CCTexture2D:setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888)
    else
        sprite = spriteClass:create(filename)
    end
end

if string.byte(filename) == 35 then -- first char is #
    local frame = display.newSpriteFrame(string.sub(filename, 2))
    if frame then
        sprite = spriteClass:createWithSpriteFrame(frame)
    end
else
    local absfilename = io.getres(filename)
    if display.TEXTURES_PIXEL_FORMAT[filename] then
        CCTexture2D:setDefaultAlphaPixelFormat(display.TEXTURES_PIXEL_FORMAT[filename])
        sprite = spriteClass:create(absfilename)
        CCTexture2D:setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888)
    else
        sprite = spriteClass:create(absfilename)
    end
end