scbc_repos/ssat_sdk/UATree/UAT_tree.py

# -*- coding:utf-8 -*-
import os, sys, time,json
from collections import OrderedDict
from ssat_sdk.utils.string_util import strToList
from UAT_log import error,info,debug
DEBUG = True
INFO = True
ERROR = True
class FirstLevel():
    ParentCol = 0
    ShortCutKeyCol = ParentCol + 1
    UIViewCol = ParentCol + 2
    MoveKeyCol = ParentCol + 3
    ToParentKeyCol = ParentCol + 4
    LayoutCol = ParentCol + 5
    OptionCol = ParentCol + 6
    OptionViewCol = ParentCol + 7
    FocusSelectCol = ParentCol + 8
    FocuseViewCol = ParentCol + 9
    EnterKeyCol = ParentCol + 10
    TextValueCol = ParentCol + 11
    InfoViewCol = ParentCol + 12
    OthersCol = ParentCol + 13

class NLevel():
    ParentCol = 0
    UIViewCol = ParentCol + 1
    MoveKeyCol = ParentCol + 2
    ToParentKeyCol = ParentCol + 3
    LayoutCol = ParentCol + 4
    OptionCol = ParentCol + 5
    OptionViewCol = ParentCol + 6
    FocusSelectCol = ParentCol + 7
    FocuseViewCol = ParentCol + 8
    EnterKeyCol = ParentCol + 9
    TextValueCol = ParentCol + 10
    InfoViewCol = ParentCol + 11
    OthersCol = ParentCol + 12

class DialogLevel():
    DialogCol = 0
    UIViewCol = DialogCol + 1
    MoveKeyCol = DialogCol + 2
    ToParentKeyCol = DialogCol + 3
    LayoutCol = DialogCol + 4
    OptionCol = DialogCol + 5
    OptionViewCol = DialogCol + 6
    FocusSelectCol = DialogCol + 7
    FocuseViewCol = DialogCol + 8
    EnterKeyCol = DialogCol + 9
    TextValueCol = DialogCol + 10
    InfoViewCol = DialogCol + 11
    OthersCol = DialogCol + 12

FirstPrev = "first-prev"
class UATTree():
    TAB_NAME = "name"
    TAB_SHORTCUT_KEY = "shortcut_key"
    TAB_UI_VIEW = "uiview"
    TAB_MOVE_KEY = "move_key"
    TAB_TOPARENT_KEY = "toparent_key"
    TAB_LAYOUT = "layout"
    TAB_OPTION = "option"
    TAB_LEVEL = "level"
    TAB_PREV_PARENT = "prev_parent"
    TAB_NEXT_PARENT = "next_parent"
    TAB_OPTION_VIEW = "optionView"
    TAB_FOCUS_SELECT = "focus-select"
    TAB_FOCUSE_VIEW = "focuseView"
    TAB_TEXT_VALUE = "textValue"
    TAB_ENTER_KEY = "enter_key"
    TAB_PARENT_NAME = "parentName"
    TAB_INFO_VIEW = "infoView"
    TAB_OTHERS = "others"

    def __init__(self):
        self.treeDict = OrderedDict()
        self.dialogDict = OrderedDict()
        self.cls = "UATTree"

    '''
    char为该项参数的括符符号，必须成对带入。默认为中括号[]
    '''
    #将数据从excel表格里取出来，只返回括号里面的内容
    def parseParam(self, key, params, char = "[]"):
        # 为防止key在其他地方存在相同关键字，添加一个"["做区别
        key1 = key + char[0]
        keyIndex = params.find(key1)
        if keyIndex == -1:
            return ""
        # key.__len__()-1 为去掉"["的处理
        str1 = params[keyIndex + key1.__len__()-1:params.__len__()]
        i1 = str1.find(char[0])
        if key == self.View_Bounds or key == self.View_sambounds:
            i2 = str1.find("]]")+1
        else:
            i2 = str1.find(char[1])
        if i1 == -1 or i2 == -1:
            return ""
        str2 = str1[i1 + 1: i2]
        return str2.strip()

    def findAllParam(self, key, params,seg="[]"):
        paramArr = []
        # for i in range(2):
        while True:
            keyIndex = params.find(key)
            if keyIndex == -1:
                break
            endIndex = params.find(seg[1])
            oneParam = params[keyIndex+key.__len__()+1:endIndex]
            params = params[endIndex+1:]
            paramArr.append(oneParam)
        return paramArr

    '''
    返回:{key:value,key2:value2,...}
    '''
    def parseMulParam(self, keyList, params):
        paramDict = {}
        for key in keyList:
            if key == 'text':
                value = self.parseMulText(params)
            else:
                value = self.parseParam(key, params)
            paramDict[key] = value
        return paramDict

    '''
    例如：enter_key,event[]ir[]同时存在多个
    返回：[[key,value],[key,value],...]
    '''
    def parseMulParam_Same(self, keyList, params):
        mulParam=[]
        for key in keyList:
            paramArr = self.findAllParam(key, params)
            for param in paramArr:
                keyItem = [key]
                keyItem.append(param)
                mulParam.append(keyItem)
        return mulParam

    #KeyDict数据
    Key_AM = "am" #android am命令
    Key_Event = "event" #android KeyEvent
    Key_IR = "ir" #红外按键
    Key_Input = "input" #Android input命令
    Max_Try = "max_try"
    #根据key的字符串，解析出key的字典。格式：am[]event[]ir[]组合
    '''
    用于解析move key参数
    '''
    def parseKey(self, keyStr):
        keyList = [self.Key_AM, self.Key_Event, self.Key_IR, self.Key_Input, self.Max_Try]
        keyDict = self.parseMulParam(keyList, keyStr)
        keyDict[self.Key_Event] = strToList(keyDict[self.Key_Event], ",")
        keyDict[self.Key_IR] = strToList(keyDict[self.Key_IR], ",")
        return keyDict

    '''
    不考虑按键种类，解析按键名、等待时间等参数，enter,wait=1,enterParent=hdmi_settings
    返回结果：{"keyvalue":[left,right,enter],"wait":'1',"times":"1"}
    '''
    def parseKeyParam(self, keyParamStr):
        paramDict = {self.Key_Value:[],self.Wait_Time:'0', self.Key_Times:'1', self.Duration_Time:'1'}
        paramArr = strToList(keyParamStr,",")
        keyValue=[]
        for param in paramArr:
            if "=" not in param:
                keyValue.append(param.strip())
            else:
                pArr = strToList(param,"=")
                paramDict[pArr[0].strip().lower()] = pArr[1].strip()
        paramDict[self.Key_Value] = keyValue
        return paramDict

    # enterKeyDict数据
    Wait_Time = "wait"
    Duration_Time = "duration"
    Enter_Parent = "enterparent"
    Key_Value = "keyvalue"
    Key_Type = "keytype"
    Key_Param = "key_param"
    Key_Times = "times"
    # 根据key的字符串，解析出key的字典。格式：am[]event[]ir[]组合
    '''
    返回值：[{"enterParent":"","key_param":{"keyType","event","keyvalue":[left,right,enter],"wait":1,"enterParent":"hdmi_settings"}}
    ,...]
    '''
    def parseEnterKey(self, keyStr, optionName):
        keyList = [self.Key_Event, self.Key_IR, self.Key_Input]
        keyArr = self.parseMulParam_Same(keyList, keyStr)
        retArr = []
        for keyItem in keyArr:
            nextPDict = {} #{"enterParent":"","key_param":{"keyType","event","keyvalue":[left,right,enter],"wait":1,"enterParent":"hdmi_settings"}}
            keyParamDict = self.parseKeyParam(keyItem[1])
            keyParamDict[self.Key_Type] = keyItem[0]
            nextPDict[self.Key_Param] = keyParamDict
            keyParamDict[self.Wait_Time] = float(keyParamDict[self.Wait_Time])
            keyParamDict[self.Duration_Time] = float(keyParamDict[self.Duration_Time])
            keyParamDict[self.Key_Times] = int(keyParamDict[self.Key_Times])
            if keyParamDict.has_key(self.Enter_Parent) is False:
                keyParamDict[self.Enter_Parent] = optionName
            nextPDict[self.Enter_Parent] = keyParamDict[self.Enter_Parent]
            retArr.append(nextPDict)
        return retArr

    #Android View数据
    View_ID = "resid" #android view resource-id
    View_Text = "text" #android view 文本内容。 用于焦点定位，文本组件坐标被焦点组件坐标包含
    View_Desc = "desc" #android view描述
    View_Bounds = "bounds" #android view 坐标
    View_Index = "index"
    View_Class = "class"
    '''
    主要用于infoView数据解析
    '''
    def parseView(self, viewStr):
        keyList = [self.View_ID, self.View_Text, self.View_Desc, self.View_Bounds, self.View_Index, self.View_Class]
        paramDict = self.parseMulParam(keyList, viewStr)
        paramDict[self.View_Bounds] = self.strToBounds(paramDict[self.View_Bounds])
        return paramDict

    '''
    将‘[801,116][1280,180]’转成数组[[801,116][1280,180]]
    '''
    def strToBounds(self, bstr):
        char = "[]"
        # print "strToBounds,bstr:", bstr,bstr.__len__()
        if bstr.__len__() < 10:
            return []
        keyIndex = 1
        # key.__len__()-1 为去掉"["的处理
        i1 = bstr.find(char[0])
        i2 = bstr.find(char[1])
        if i1 == -1 or i2 == -1:
            return []
        str1 = bstr[i1: i2 + 1]
        str2 = bstr[i2 + 1: bstr.__len__()]
        return [eval(str1), eval(str2)]

    '''
    解析多文本option,更改key亦可作为其他参数
    '''
    def parseMulText(self,params, char="[]",key = 'text'):
        key1 = key + char[0] + char[0]
        keyIndex = params.find(key1)
        if keyIndex == -1:
            text = self.parseParam(key, params)  # 只有一层中括号
        else:
            text = []
            str1 = params[keyIndex + key1.__len__() - 1:len(params)]
            i1 = str1.find(char[0])
            i2 = str1.find((char[1] + char[1]))
            if i1 == -1 or i2 == -1:
                return ""
            str2 = str1[i1:i2 + 1]  # 只去掉外括号
            strList = strToList(str2, char[1] + "," + char[0])
            for strs in strList:
                text.append(strs.strip(char[0]).strip(char[1]))
        return text
		
    View_sambounds = "sambounds" #采样时的样本坐标，用于和select-focus、focusView的坐标做相对比较，计算相对位置，用于确定是否被选中。
    # 即选中状态的坐标，option中组件选中状态下的坐标和focus-select/focusView中组件选中状态下的坐标
    # 分别写在optionView和focus-select/focusView中，其实就类似用sambounds做为组件
    '''
    用于optionView的数据解析
    '''
    def parseOptionView(self, viewStr):
        keyList = [self.View_ID, self.View_Text, self.View_Desc, self.View_Bounds, self.View_Index, self.View_Class
                   ,self.View_sambounds]
        paramDict = self.parseMulParam(keyList, viewStr)
        paramDict[self.View_Bounds] = self.strToBounds(paramDict[self.View_Bounds])
        paramDict[self.View_sambounds] = self.strToBounds(paramDict[self.View_sambounds])
        return paramDict

    # UI 界面数据
    UIView_Activity = "activity"  # android activity
    UIVIew_Action = "action"
    # UIView_ID = "resid"  # android view resource-id
    # UIView_Text = "text"  # android view 文本内容
    # UIView_Desc = "desc"  # android view描述
    # UIView_Bounds = "bounds"  # android view 坐标
    UIView_Dialog_F = "dialog_forward"  # 进入时可能出现的弹窗
    UIView_Dialog_B = "dialog_back"  # 退出时可能出现的弹窗
    def parseUIView(self, viewStr):
        keyList = [self.UIView_Activity, self.UIVIew_Action, self.View_ID, self.View_Text, self.View_Desc,
                   self.View_Bounds, self.UIView_Dialog_F, self.UIView_Dialog_B]
        uiView = self.parseMulParam(keyList, viewStr)
        return self.parseDialogParam(uiView)

    def parseDialogParam(self, uiView):
        dialog_F_List = strToList(uiView[self.UIView_Dialog_F], ",")
        dialog_B_List = strToList(uiView[self.UIView_Dialog_B], ",")
        self.addDialogList(dialog_F_List, uiView, True)
        self.addDialogList(dialog_B_List, uiView, False)
        return uiView

    def addDialogList(self, dialog_List, uiView, isForward):
        for dialog in dialog_List:
            dialog_A = strToList(dialog.lower(), "&")
            if dialog_A.__len__() == 2:
                dialog_Name = dialog_A[0]
                dialog_Choose = dialog_A[1]
            else:
                error(str(self.__class__), "parseDialogParam", "Dialog %s set error"%dialog, ERROR)
                return
            if self.dialogDict.has_key(dialog_Name):
                if isForward is True:
                    dialog_Type = self.UIView_Dialog_F
                else:
                    dialog_Type = self.UIView_Dialog_B
                uiView[dialog_Type] = {}
                uiView[dialog_Type][dialog_Name] = self.dialogDict[dialog_Name]
                uiView[dialog_Type][dialog_Name]["choose"] = self.dialogDict[dialog_Name][UATTree.TAB_OPTION][dialog_Choose]
            else:
                error(str(self.__class__), "parseDialogParam", "Dialog %s read fail"%dialog_Name, ERROR)


    # Android Layout数据
    # Layout_ID = "resid"  # android view resource-id
    # Layout_Desc = "desc"  # android view描述
    # Layout_Bounds = "bounds"  # android view 坐标
    # Layout_Class = "class" #android view class类型
    Layout_Limit = "limit" #layout是否限制optionView焦点操作范围。0：不限制，1:限制，默认为0
    '''
    layout：各属性值，用于综合确定一个布局组件
    :return layout 字典：{"resid":"","desc":"","bounds":""}
    '''
    def parseLayout(self, viewStr):
        keyList = [self.View_ID, self.View_Desc, self.View_Bounds, self.View_Class, self.Layout_Limit]
        paramDict = self.parseMulParam(keyList, viewStr)
        if paramDict.has_key(self.Layout_Limit) and paramDict[self.Layout_Limit].__len__()>0:
            paramDict[self.Layout_Limit] = int(paramDict[self.Layout_Limit]) #字符'0'转数字0
        paramDict[self.View_Bounds] = self.strToBounds(paramDict[self.View_Bounds])
        return paramDict

    #Android FocusView数据
    # Focus_ID = "resid" #android view resource-id
    # Focus_Text = "text" #android view 文本内容
    # Focus_Desc = "desc" #android view描述
    # Focus_Bounds = "bounds" #android view 坐标
    # Focus_Class = "class"
    def parseFocus(self, viewStr):
        keyList = [self.View_ID, self.View_Text, self.View_Desc, self.View_Bounds, self.View_Class,
                   self.View_sambounds]
        paramDict = self.parseMulParam(keyList, viewStr)
        paramDict[self.View_Bounds] = self.strToBounds(paramDict[self.View_Bounds])
        paramDict[self.View_sambounds] = self.strToBounds(paramDict[self.View_sambounds])
        return paramDict

    #Value数据
    # ValueView_ID = "resid" #android view resource-id
    # ValueView_Text = "text" #android view 文本内容
    # ValueView_Desc = "desc" #android view描述
    # ValueView_Bounds = "bounds"
    # ValueView_Class = "class"
    ValueView_Value = "value"  # 输入的值范围。格式：first, second, ...  或者 0-100
    ValueView_Min = "minvalue" # 如果是数值范围形式的值，返回最小值
    ValueView_Max = "maxvalue" # 如果是数值范围形式的值，返回最小值
    ValueView_StepSize = "stepsize" # 如果是数值范围形式的值，每次调整数值的步长。读不到此参数时，默认为1。
    ValueView_Duration = "duration" # 如果是数值范围形式的值，每次调整数值的间隔时间。读不到此参数时，默认为0.2。
    ValueView_Sign = "sign" # 针对前缀为字母，后缀为数字形式的值，用来保存前缀
    def parseValueView(self, viewStr):
        keyList = [self.View_ID, self.View_Text, self.View_Desc, self.ValueView_Value,
                   self.ValueView_StepSize, self.ValueView_Duration, self.View_Bounds, self.View_Class,
                   self.View_sambounds]
        paramDict = self.parseMulParam(keyList, viewStr)
        valueStr = paramDict[self.ValueView_Value]
        sign = []
        valueListDelStr = []
        flagList = []
        flag_v = False # value前缀不为字母
        if valueStr != "":
            i = valueStr.find(",")
            if i != -1:
                valueList = strToList(valueStr, ",")
                isRange = False

                # 前缀字母，后缀数字
                for val in valueList:
                    if (ord(val[0])>57 or ord(val[0])<48) and (47 < ord(val[1]) < 58):
                        sign.append(val[0])
                        valueDelStr = val.strip(val[0])
                        valueListDelStr.append(valueDelStr)
                        flagList.append(True)  #value前缀为字母
                    else:
                        flagList.append(False)
                for f in flagList:
                    flag_v = f
                    flag_v = flag_v and f
                if flag_v == False:
                    sign = []
                # 处理range类型（数值）
                try:
                    if valueList.__len__() == 2:
                        if flag_v == True: #//
                            valueList = valueListDelStr
                            paramDict[self.ValueView_Min] = -float(valueList[0])#//
                        else:
                            paramDict[self.ValueView_Min] = float(valueList[0])
                        paramDict[self.ValueView_Max] = float(valueList[1])
                        isRange = True
                except Exception,ValueError:
                    info(self.cls, "parseValueView", "valueList %s not range value.", INFO)
                # 处理非range类型（选项）
                if isRange is False:
                    for value in valueList:
                        valueViewStr = self.parseParam(value, viewStr, "{}")
                        if valueViewStr == "":
                            debug(self.cls, "parseValueView", "value %s 没有任何配置信息！！！请加入该value信息，否则可能将导致设值失败！！！"%value, DEBUG)
                        # 读出来的数值未带大括号，需加上大括号，并且json格式化
                        valueView = eval("{%s}" % valueViewStr)
                        paramDict[value] = valueView
        paramDict[self.ValueView_Sign] = sign
        return paramDict

    #focus-select数据，不仅有select或者focus类型，还有指定组件属性情况，用于处理界面多个聚焦方式出现的场景
    FS_Type = "type"
    FS_checkType = "checkType"
    # FS_ID = "resid" #android view resource-id
    # FS_Text = "text" #android view 文本内容。
    # FS_Desc = "desc" #android view描述
    # FS_Bounds = "bounds" #android view 坐标
    # FS_Class = "class"
    def parseFocusSelectType(self, fsType):
        keyList = [self.FS_Type,self.View_ID,self.View_Text,self.View_Desc,self.View_Bounds,
                   self.View_sambounds,self.View_Class,self.FS_checkType]
        paramDict = self.parseMulParam(keyList, fsType)
        paramDict[self.View_sambounds] = self.strToBounds(paramDict[self.View_sambounds])
        return paramDict

    '''
    扫描parent数据行时，要把建立当前parent的prevParent和nextParent关系。
    '''
    def addParent(self,level, parentName, shortkey, uiview, move_key, toparent_key, layout, others):
        # print "addParent, level,parentName:", level, parentName
        if not self.treeDict.has_key(level):
            self.treeDict[level] = {}
        parentDict = {}
        parentDict[UATTree.TAB_NAME] = parentName
        parentDict[UATTree.TAB_SHORTCUT_KEY] = self.parseKey(shortkey)
        parentDict[UATTree.TAB_UI_VIEW] = self.parseUIView(uiview)
        parentDict[UATTree.TAB_MOVE_KEY] = self.parseKey(move_key)
        parentDict[UATTree.TAB_TOPARENT_KEY] = self.parseKey(toparent_key)
        parentDict[UATTree.TAB_LAYOUT] = self.parseLayout(layout)
        parentDict[UATTree.TAB_OPTION] = {}
        parentDict[UATTree.TAB_LEVEL] = level
        parentDict[UATTree.TAB_PREV_PARENT] = None
        parentDict[UATTree.TAB_NEXT_PARENT] = {}
        parentDict[UATTree.TAB_OTHERS] = self.parseOthers(others)
        if "first" <> level:
            prevParent = self.getPreParentByParent(parentDict)
            if prevParent is not None:
                parentDict[UATTree.TAB_PREV_PARENT] = prevParent
                prevParent[UATTree.TAB_NEXT_PARENT][parentName] = parentDict
        self.treeDict[level][parentName] = parentDict

    '''
    扫描option行的时候，会把option字典关联到相应的parent字典里
    '''
    def addOption(self, level, parentName, optionName, optionView, focusSelect, focusView, enterKey, textValue, infoView):
        # print "addOption, level,parentName,optionName:", level, parentName,optionName
        if self.treeDict.has_key(level) and self.treeDict[level].has_key(parentName):
            optionDict = {}
            optionDict[UATTree.TAB_NAME] = optionName
            optionDict[UATTree.TAB_OPTION_VIEW] = self.parseOptionView(optionView)
            optionDict[UATTree.TAB_FOCUS_SELECT] = self.parseFocusSelectType(focusSelect)
            optionDict[UATTree.TAB_FOCUSE_VIEW] = self.parseFocus(focusView)
            optionDict[UATTree.TAB_ENTER_KEY] = self.parseEnterKey(enterKey, optionName)
            optionDict[UATTree.TAB_TEXT_VALUE] = self.parseValueView(textValue)
            optionDict[UATTree.TAB_INFO_VIEW] = self.parseView(infoView)
            optionDict[UATTree.TAB_PARENT_NAME] = parentName
            optionDict[UATTree.TAB_LEVEL] = level
            self.treeDict[level][parentName][UATTree.TAB_OPTION][optionName] = optionDict

    def addDialog(self, parentName, shortkey, uiview, move_key, toparent_key, layout, others):
        # print "addDialog, parentName:", parentName
        parentDict = {}
        parentDict[UATTree.TAB_NAME] = parentName
        parentDict[UATTree.TAB_SHORTCUT_KEY] = self.parseKey(shortkey)
        parentDict[UATTree.TAB_UI_VIEW] = self.parseUIView(uiview)
        parentDict[UATTree.TAB_MOVE_KEY] = self.parseKey(move_key)
        parentDict[UATTree.TAB_TOPARENT_KEY] = self.parseKey(toparent_key)
        parentDict[UATTree.TAB_LAYOUT] = self.parseLayout(layout)
        parentDict[UATTree.TAB_OPTION] = {}
        parentDict[UATTree.TAB_OTHERS] = self.parseDialogOthers(others)

        self.dialogDict[parentName] = parentDict

    def addDialogOption(self, parentName, optionName, optionView, focusSelect, focusView, enterKey, textValue, infoView):
        # print "addDialogOption, parentName,optionName:", parentName, optionName
        if self.dialogDict.has_key(parentName):
            optionDict = {}
            optionDict[UATTree.TAB_NAME] = optionName
            optionDict[UATTree.TAB_OPTION_VIEW] = self.parseOptionView(optionView)
            optionDict[UATTree.TAB_FOCUS_SELECT] = self.parseFocusSelectType(focusSelect)
            optionDict[UATTree.TAB_FOCUSE_VIEW] = self.parseFocus(focusView)
            optionDict[UATTree.TAB_ENTER_KEY] = self.parseEnterKey(enterKey,optionName)
            optionDict[UATTree.TAB_TEXT_VALUE] = self.parseValueView(textValue)
            optionDict[UATTree.TAB_INFO_VIEW] = self.parseView(infoView)
            optionDict[UATTree.TAB_PARENT_NAME] = parentName
            self.dialogDict[parentName][UATTree.TAB_OPTION][optionName] = optionDict


    def findParentDict(self, parentName):
        parentName = parentName.lower()
        levelList = self.treeDict.keys()
        for index in range(levelList.__len__()-1, -1, -1):
            level = levelList[index]
            if self.treeDict[level].has_key(parentName):
                return self.treeDict[level][parentName]
        return None

    def getSubOptionDict(self, parentName):
        parentDict = self.findParentDict(parentName)
        if parentDict is not None:
            return parentDict[UATTree.TAB_OPTION]
        return None

    def findOption(self, optionName):
        optionName = optionName.lower()
        levelList = self.treeDict.keys()
        for index in range(levelList.__len__()-1, -1, -1):
            level = levelList[index]
            levelDict = self.treeDict[level]
            for parent in levelDict.keys():
                parentDict = levelDict[parent]
                for option in parentDict.keys():
                    optionDict = parentDict[UATTree.TAB_OPTION]
                    if optionDict.has_key(optionName):
                        return optionDict[optionName]

    def getOpitonInLevel(self,targetOptionName, level):
        levelDict = self.treeDict[level]
        for parentName in levelDict.keys():
            parentDict = levelDict[parentName]
            for optionName in parentDict[UATTree.TAB_OPTION].keys():
                if targetOptionName == optionName:
                    return parentDict[UATTree.TAB_OPTION][optionName]
        else:
            return None

    '''
   检测option的enter_key中是否存在对应parentName
   '''
    def checkEnterParentEK(self, enterKey, parentName):
        # print "checkEnterParentEK,enterKey,parentName:",enterKey, parentName
        for keyItem in enterKey:
            if keyItem[self.Enter_Parent] == parentName:
                return True
        return False
    '''
    检测option字典，是否下一级nextParent包含这一个parentName
    '''
    def checkOptionEnterParent(self, option, parentName):
        enterKey = option[self.TAB_ENTER_KEY]
        if option[self.TAB_NAME] == parentName:
            return True
        return self.checkEnterParentEK(enterKey, parentName)

    '''
    根据parentName，在EnterKey所有列表中，找到匹配的enterKey字典选项
    返回值：{"enterParent":"","key_param":{"keyType":"event","keyvalue":[left,right,enter],"wait":1,"enterParent":"hdmi_settings"}
    '''
    def getEKByParent(self, enterKeys, parentName):
        for keyItem in enterKeys:
            if keyItem[self.Enter_Parent] == parentName:
                return keyItem[self.Key_Param]
        return None
    '''
    获取option的parent
    '''
    def getParentByOption(self, option):
        parentName = option[UATTree.TAB_PARENT_NAME]
        levelName = option[UATTree.TAB_LEVEL]
        if self.treeDict[levelName].has_key(parentName):
            parent = self.treeDict[levelName][parentName]
            return parent
        else:
            return None

    '''
    根据Parent数据，查上一级parent。
    '''
    def getPreParentByParent(self, parent):
        prevLevel = self.getPrevLevel(parent[self.TAB_LEVEL])
        levelDict = self.treeDict[prevLevel]
        # print "getPreParentByParent,levelDict:",levelDict
        for parentName in levelDict.keys():
            parentDict = levelDict[parentName]
            # print "getPreParentByParent,parentDict:", parentDict
            for optionName in parentDict[UATTree.TAB_OPTION].keys():
                option = parentDict[UATTree.TAB_OPTION][optionName]
                # print "getPreParentByParent,option:", option
                if self.checkOptionEnterParent(option, parent[self.TAB_NAME]):
                    return parentDict
        error(str(self.__class__), "getPreParentByParent",
              "Parent %s's prevparent not found in level %s"%(parent[self.TAB_NAME], prevLevel), ERROR)
        return None

    '''
    获取当前level的前一个level名
    '''
    def getPrevLevel(self, level):
        self.levelList = self.treeDict.keys()
        index = self.levelList.index(level)
        if index == 0:
            return FirstPrev
        else:
            return self.levelList[index-1]
    '''
    获取当前Parent的上一级parent
    '''
    def getPrevParent(self, parent):
        return parent[UATTree.TAB_PREV_PARENT]

    '''
    获取当前parent下一级所有parent的字典
    '''
    def getNextParentList(self, parent):
        return parent[UATTree.TAB_NEXT_PARENT]

    def printTree(self):
        for level in self.treeDict.keys():
            print level
            for parent in self.treeDict[level].keys():
                dict1 = self.treeDict[level][parent]
                print level, "::parent ", dict1["name"], "name", "shortcut_key", "uiview", "move_key", "toparent_key", "layout"
                print level, "::parent ", dict1["name"], dict1["shortcut_key"], dict1["uiview"], dict1["move_key"], dict1["toparent_key"], dict1["layout"]
                for option in dict1["option"].keys():
                    dict2 = dict1["option"][option]
                    print level, "::option ", dict2

    Key_HeartBeat = "heartbeat_key"
    def parseOthers(self, othersStr):
        othersDict = {}
        othersDict[self.Key_HeartBeat] = self.parseParam(self.Key_HeartBeat, othersStr, char="{}")
        hb_keyDict = {}
        if othersDict[self.Key_HeartBeat] != "":
            print "Key_HeartBeat_Str:",othersDict[self.Key_HeartBeat]
            hb_keyDict = self.parseHeartBeatKey(othersDict[self.Key_HeartBeat])
        othersDict[self.Key_HeartBeat] = hb_keyDict
        return othersDict
		
    def parseHeartBeatKey(self, hb_keyStr):
        keyList = [self.Key_Event, self.Key_IR]
        keyDict = self.parseMulParam(keyList, hb_keyStr)
        keyDict[self.Key_Event] = strToList(keyDict[self.Key_Event], ",")
        keyDict[self.Key_IR] = strToList(keyDict[self.Key_IR], ",")
        return keyDict
		
    def parseDialogOthers(self, othersStr):
        othersDict = {}
        othersDict[self.Key_HeartBeat] = self.parseParam(self.Key_HeartBeat, othersStr, char="{}")
        hb_keyDict = {}
        if othersDict[self.Key_HeartBeat] != "":
            print "Key_HeartBeat_Str:",othersDict[self.Key_HeartBeat]
            hb_keyDict = self.parseHeartBeatKey(othersDict[self.Key_HeartBeat])
        othersDict[self.Key_HeartBeat] = hb_keyDict
        return othersDict

if __name__ == '__main__':
    uatTree = UATTree()