HiGV ui代碼流程

在海思PDT_Init下有一個這樣的函數HI_PDT_UI_Init()：

1. HI_PDT_UI_Init()函數：

/*public, it should be called by main()*/
HI_S32 HI_PDT_UI_Init(HI_VOID)
{
    HI_S32 s32Ret = HI_SUCCESS;

    s32Ret = PDT_UI_StartLCD();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

#ifdef CFG_TIME_MEASURE_ON
    HI_PrintBootTime("UI");
#endif

    s32Ret = PDT_UI_COMM_SubscribeEvents();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = PDT_UI_POWERCTRL_Init();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    return HI_SUCCESS;
}

2. PDT_UI_StartLCD()函數

HI_S32 PDT_UI_StartLCD(HI_VOID)
{
    HI_S32 s32Ret = HI_SUCCESS;
    HI_HAL_SCREEN_ATTR_S stScreenAttr = {};
    HI_S32 s32ScreenWidth = 0;
    HI_S32 s32ScreenHeight = 0;

    s_bLCD = HI_TRUE;

    s32Ret = PDT_UI_InitHigv();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = PDT_UI_WINMNG_Init();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    if(INVALID_HANDLE == s_LCDLayerHandle)
    {
        /* GetLayer Id */
        HIGO_LAYER_E enLayerId = HIGO_LAYER_HD_0;
        s32Ret = PDT_UI_GetLayerId(HI_PDT_WORKMODE_NORM_REC, &enLayerId);
        HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

#ifdef CONFIG_SCREEN
        s32Ret = HI_HAL_SCREEN_GetAttr(HI_HAL_SCREEN_IDX_0, &stScreenAttr);
        HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);
#endif

        s32ScreenWidth = (HI_S32)stScreenAttr.stAttr.u32Width;
        s32ScreenHeight = (HI_S32)stScreenAttr.stAttr.u32Height;

        HIGO_LAYER_INFO_S LayerInfo = {
            s32ScreenWidth, s32ScreenHeight,             /* Screen */
            LCD_XML_LAYOUT_WIDTH, LCD_XML_LAYOUT_HEIGHT, /* Canvas, same as the window width,height in XML */
            s32ScreenWidth, s32ScreenHeight,             /* Display */
            HIGO_LAYER_FLUSH_OVER, HIGO_LAYER_DEFLICKER_AUTO, HIGO_PF_4444,  enLayerId};

        MLOGD(GREEN"Create layer, Screen[%u * %u], Canvas[%u * %u], Display[%u * %u]\n"NONE,
            s32ScreenWidth, s32ScreenHeight,
            LCD_XML_LAYOUT_WIDTH, LCD_XML_LAYOUT_HEIGHT,
            s32ScreenWidth, s32ScreenHeight);

        /* create graphical layer */
        s32Ret = HI_GV_Layer_Create(&LayerInfo, &s_LCDLayerHandle);
        HI_APPCOMM_CHECK_RETURN(s32Ret, s32Ret);

#if defined(CONFIG_VERTICAL_SCREEN)
        HIGV_ROTATE_E enRotate = HIGV_ROTATE_90;
#else
        HIGV_ROTATE_E enRotate = HIGV_ROTATE_NONE;
#endif

        s32Ret = HI_GV_Layer_SetRotateMode(s_LCDLayerHandle, enRotate);
        HI_APPCOMM_CHECK_RETURN(s32Ret, s32Ret);
    }
    s32Ret = HI_GV_Layer_SetDefault(s_LCDLayerHandle);

    s32Ret |= HI_GV_PARSER_LoadViewById(ALARM_WINDOW);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);
    s32Ret = HI_GV_Widget_Hide(DIALOG_WINDOW_GROUPBOX_FORMAT);

    s32Ret = PDT_UI_WINMNG_StartWindow(HOME_PAGE,HI_FALSE);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_PDT_MEDIA_SetDisplayGraphicCSC();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = PDT_UI_COMM_InitKeyTone();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    return HI_SUCCESS;
}

2.1 PDT_UI_InitHigv()函數

UI流程圖：

下面如注釋：

/*  public section between LCD and HDMI initialization*/
static HI_S32 PDT_UI_InitHigv(HI_VOID)
{
    HI_S32 s32Ret = HI_SUCCESS;
#if defined(CFG_LCD_TOUCHPAD_ON)
    s32Ret = PDT_UI_RegisterTouchDevice();      //這里是注冊觸摸屏的代碼，注冊相應的回調函數
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);
#endif

    s32Ret = HI_GV_SetVsyncType(HIGV_VSYNC_HW);     //設置 VSYNC 的信號源類型，HIGV_VSYNC_HW在hi_gv_app.h里面
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_GV_Init();
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    if(s_bLCD)
    {
        s32Ret = HI_GV_SetSWVsyncPeriod(16666); /** us */
        s32Ret |= HI_GV_SetLostFrameThreshold(8000); /** us */
    }
    else
    {
        s32Ret = HI_GV_SetSWVsyncPeriod(33333); /** us */
        s32Ret |= HI_GV_SetLostFrameThreshold(15000); /** us */
    }
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    HI_GV_Log_SetLevel(HI_NULL, HIGV_LOG_FATAL);

    s32Ret = HI_GV_PARSER_Init();

    /* set widget event callback function */
    s32Ret |= HI_GV_PARSER_SetWidgetEventFunc(g_pfunHIGVAppEventFunc, ARRAY_SIZE(g_pfunHIGVAppEventFunc));
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_GV_ScrollGrid_RegisterWidget();
    PDT_UI_CHECK_RET_WITHOUT_RETURN(s32Ret, "RegisterWidget");

    /* load higv.bin file for parser */
    s32Ret = HI_GV_PARSER_LoadFile("./higv.bin");
    if (HI_SUCCESS != s32Ret)
    {
        MLOGE("LoadFile ret:%x\n", s32Ret);
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return HI_FAILURE;
    }

    s32Ret = HI_GV_SetVsyncLostFrame(HI_FALSE);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_GV_Lan_Register(LANG_EN_FILE, FONT18, LAN_ENGLISH);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_GV_Lan_Register(LANG_CN_FILE, FONT18, LAN_CHINESE);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    HI_CHAR szContent[SETTING_CONTENT_SIZE];
    HI_CHAR szLanId[SETTING_CONTENT_SIZE];

    s32Ret = PDT_UI_COMM_GetParamValueDesc(HI_PDT_WORKMODE_BUTT, HI_PDT_PARAM_TYPE_LANGUAGE, szContent, SETTING_CONTENT_SIZE);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = PDT_UI_COMM_GetStringByString(szContent, szLanId, SETTING_CONTENT_SIZE);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    s32Ret = HI_GV_Lan_Change(szLanId);
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);
    
    
    //啟動一個新線程，開啟相應的應用界面
    s32Ret = pthread_create(&s_UiThread, NULL, (HI_VOID *)PDT_UI_StartApp, NULL);
    if (0 != s32Ret)
    {
        MLOGE("pthread_create ret:%#x\n", s32Ret);
        return HI_FAILURE;
    }

    return HI_SUCCESS;
}

2.1.1 PDT_UI_RegisterTouchDevice()

HI_S32 PDT_UI_RegisterTouchDevice(HI_VOID)
{
    HI_S32 s32Ret = HI_SUCCESS;
    HIGV_TOUCH_DEVICE_INPUT_S stInputDevice = {};
    stInputDevice.OpenDevice = HI_HAL_TOUCHPAD_Start;
    stInputDevice.CloseDevie = HI_HAL_TOUCHPAD_Stop;
    stInputDevice.ReadData   = PDT_UI_ReadTouchData;

    s32Ret = HI_GV_Gesture_RegisterDevice(&stInputDevice);      //觸摸手勢注冊入口
    s32Ret |= HI_GV_Gesture_SetTouchHook(PDT_UI_TouchHook);     //設置觸摸回調鈎子函數。
    HI_APPCOMM_CHECK_RETURN(s32Ret,s32Ret);

    return HI_SUCCESS;
}

1. HI_HAL_TOUCHPAD_Start

這個函數是獲取到設備的能力和特性

//找到addr中的對應bit.看其是否為1。
static inline HI_S32 HAL_TOUCHPAD_InputBitCheck(HI_S32 bit, const volatile HI_U32* addr)
{
    return 1UL & (addr[HAL_TOUCHAPD_BITWORD(bit)] >> (bit & (HAL_TOUCHAPD_BITLONG - 1)));
}



HI_S32 HI_HAL_TOUCHPAD_Start(HI_S32* ps32Fd)
{
    HAL_TOUCHPAD_CHECK_INIT();
    HI_APPCOMM_CHECK_POINTER(ps32Fd, HI_HAL_EINVAL);

    HI_S32 s32Ret = HI_SUCCESS;
    HI_U32 au32Inputbits[(ABS_MAX + 31) / 32];
    if (HAL_FD_INITIALIZATION_VAL != s_s32TOUCHPADfd)
    {
        MLOGE("touchpad already started\n");
        return HI_HAL_ENOSTART;
    }
    memset(&s_stHALTOUCHPADMtInput, 0, sizeof(HAL_TOUCHPAD_MTINPUT_S));
    s_s32TOUCHPADfd = open(HAL_TOUCHAPD_DEV, O_RDONLY);
    if (s_s32TOUCHPADfd < 0)
    {
        MLOGE("open /dev/input/event0 err,errno(%d)\n",errno);
        return HI_HAL_EINVOKESYS;
    }

    s32Ret = ioctl(s_s32TOUCHPADfd, EVIOCGBIT(EV_ABS, sizeof(au32Inputbits)), au32Inputbits);
    if (s32Ret < 0)
    {
        MLOGE("open ioctl err,errno(%d)\n",errno);
        close(s_s32TOUCHPADfd);
        s_s32TOUCHPADfd = HAL_FD_INITIALIZATION_VAL;
        return HI_HAL_EINVOKESYS;
    }

    if ( ( 0 == HAL_TOUCHPAD_InputBitCheck(ABS_MT_POSITION_X, au32Inputbits) )
         || ( 0 == HAL_TOUCHPAD_InputBitCheck(ABS_MT_POSITION_Y, au32Inputbits) )
         || ( 0 == HAL_TOUCHPAD_InputBitCheck(ABS_MT_TOUCH_MAJOR, au32Inputbits) )
       )
    {
        MLOGE("error: could not support the device\n");
        MLOGE("EV_SYN=%d\n", HAL_TOUCHPAD_InputBitCheck(EV_SYN, au32Inputbits));
        MLOGE("EV_ABS=%d\n", HAL_TOUCHPAD_InputBitCheck(EV_ABS, au32Inputbits));
        MLOGE("ABS_MT_POSITION_X=%d\n", HAL_TOUCHPAD_InputBitCheck(ABS_MT_POSITION_X, au32Inputbits));
        MLOGE("ABS_MT_POSITION_Y=%d\n", HAL_TOUCHPAD_InputBitCheck(ABS_MT_POSITION_Y, au32Inputbits));
        MLOGE("ABS_MT_TOUCH_MAJOR=%d\n", HAL_TOUCHPAD_InputBitCheck(ABS_MT_TOUCH_MAJOR, au32Inputbits));
        close(s_s32TOUCHPADfd);
        s_s32TOUCHPADfd = HAL_FD_INITIALIZATION_VAL;
        return HI_HAL_EINTER;
    }
    *ps32Fd = s_s32TOUCHPADfd;
    return HI_SUCCESS;
}

2. HI_HAL_TOUCHPAD_Stop()

關閉設備；

HI_S32 HI_HAL_TOUCHPAD_Stop(HI_VOID)
{
    HAL_TOUCHPAD_CHECK_INIT();
    HAL_TOUCHPAD_CHECK_FD();

    HI_S32 s32Ret = HI_SUCCESS;
    s32Ret = close(s_s32TOUCHPADfd);
    if (HI_SUCCESS != s32Ret)
    {
        MLOGD("close err,errno(%d)\n",errno);
        return HI_HAL_EINVOKESYS;
    }
    s_s32TOUCHPADfd = HAL_FD_INITIALIZATION_VAL;
    return HI_SUCCESS;
}

3. HI_HAL_TOUCHPAD_ReadInputEvent()

讀取input設備輸入信息：

static HI_S32 HAL_TOUCHPAD_ReadInputEventStatic(HAL_TOUCHPAD_MTSAMPLE_S* pstMtSamp)
{
    struct input_event stInputEvent;
    HI_S32 s32Ret = HI_SUCCESS;
    HI_BOOL bDataReadCompleted = HI_FALSE;
    HI_S32 s32Pushed = 0;

    /** parm ps32Level check */
    if (NULL == pstMtSamp)
    {
        MLOGE("pstMtSamp is null\n");
        return HI_FAILURE;
    }
    /** init check */
    if (HAL_FD_INITIALIZATION_VAL == s_s32TOUCHPADfd)
    {
        MLOGE("touchpad not initialized\n");
        return HI_FAILURE;
    }
    while (HI_FALSE == bDataReadCompleted)
    {
        s32Ret = read(s_s32TOUCHPADfd, &stInputEvent, sizeof(struct input_event));

        if (s32Ret < (HI_S32)sizeof(struct input_event))
        {
            /** no more data */
            MLOGW("s32Ret(%d) <sizeof(struct input_event)(%d)\n",(HI_S32)s32Ret,(HI_S32)sizeof(struct input_event));
            break;
        }

        switch (stInputEvent.type)
        {
                /** key 0x1*/
            case EV_KEY:

                //MLOGD("event=EV_KEY:\n");
                switch (stInputEvent.code)
                {
                        /** 14a 0 */
                    case BTN_TOUCH:
                        (&s_stHALTOUCHPADMtInput)->au32Pressure[(&s_stHALTOUCHPADMtInput)->s32Slot] = stInputEvent.value;
                        (&s_stHALTOUCHPADMtInput)->as32Filled[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        break;
                }

                break;

                /** 0x00 */
            case EV_SYN:
                switch (stInputEvent.code)
                {
                    case SYN_REPORT:
                    case SYN_MT_REPORT:
                    default:
                        //MLOGD("event=%d.code=%d\n", stInputEvent.type, stInputEvent.code);
                    {
                        s32Pushed = HAL_TOUCHPAD_PushSamp(&s_stHALTOUCHPADMtInput, &stInputEvent, pstMtSamp);
                        pstMtSamp += s32Pushed;
                        bDataReadCompleted = HI_TRUE;
                    }
                    break;
                }

                break;

                /** 0x3 */
            case EV_ABS:
                switch (stInputEvent.code)
                {
                        /** 0x3a Pressure on contact area */
                    case ABS_PRESSURE:
                        //MLOGD("event.code=ABS_PRESSURE.v=%d\n", stInputEvent.value);
                        (&s_stHALTOUCHPADMtInput)->au32Pressure[(&s_stHALTOUCHPADMtInput)->s32Slot] = stInputEvent.value;
                        break;

                        /** 0x2f MT slot being modified */
                    case ABS_MT_SLOT:

                        //MLOGD("event.code=ABS_MT_SLOT.v=%d\n", stInputEvent.value);
                        if (stInputEvent.value < 0)
                        {
                            break;
                        }

                        (&s_stHALTOUCHPADMtInput)->s32Slot = stInputEvent.value;
                        if ((&s_stHALTOUCHPADMtInput)->s32Slot >= HAL_TOUCHAPD_MAX_POINT_NUM)
                        {
                            //MLOGD("slot limit error. MAX_POINT_NUM=%d. temp slot=%d\n", MAX_POINT_NUM, (&s_stmtinput)->temp_slot);
                            (&s_stHALTOUCHPADMtInput)->s32Slot = 0;
                        }
                        break;

                        /** 0X30 Major axis of touching ellipse */
                    case ABS_MT_TOUCH_MAJOR:
                        //MLOGD("event.code=ABS_MT_TOUCH_MAJOR.v=%d\n", stInputEvent.value);
                        (&s_stHALTOUCHPADMtInput)->au32Pressure[(&s_stHALTOUCHPADMtInput)->s32Slot] = stInputEvent.value;
                        (&s_stHALTOUCHPADMtInput)->as32Filled[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        break;

                        /** 0X35 */
                    case ABS_MT_POSITION_X:
                        //MLOGD("event.code=ABS_MT_POSITION_X.v=%d\n", stInputEvent.value);
                        (&s_stHALTOUCHPADMtInput)->as32X[(&s_stHALTOUCHPADMtInput)->s32Slot] = stInputEvent.value;
                        (&s_stHALTOUCHPADMtInput)->au32Pressure[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        (&s_stHALTOUCHPADMtInput)->as32Filled[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;

                        break;

                        /** 0X36 */
                    case ABS_MT_POSITION_Y:
                        //MLOGD("event.code=ABS_MT_POSITION_Y.v=%d\n", stInputEvent.value);
                        (&s_stHALTOUCHPADMtInput)->as32Y[(&s_stHALTOUCHPADMtInput)->s32Slot] = stInputEvent.value;
                        (&s_stHALTOUCHPADMtInput)->au32Pressure[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        (&s_stHALTOUCHPADMtInput)->as32Filled[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        break;

                        /** 0X39 */
                    case ABS_MT_TRACKING_ID:

                        //MLOGD("event.code=ABS_MT_TRACKING_ID.v=%d\n", stInputEvent.value);
                        if (stInputEvent.value == -1)
                        {
                            (&s_stHALTOUCHPADMtInput)->as32Filled[(&s_stHALTOUCHPADMtInput)->s32Slot] = 1;
                        }
                        break;
                }

                break;
        }
    }

    return HI_SUCCESS;
}

HI_S32 HI_HAL_TOUCHPAD_ReadInputEvent(HI_HAL_TOUCHPAD_INPUTINFO_S* pstInputData)
{
    HI_APPCOMM_CHECK_POINTER(pstInputData, HI_HAL_EINVAL);
    HAL_TOUCHPAD_CHECK_INIT();
    HAL_TOUCHPAD_CHECK_FD();

    HI_S32 s32Ret = HI_SUCCESS;

    HAL_TOUCHPAD_MTSAMPLE_S astMtSample[HAL_TOUCHAPD_MAX_POINT_NUM];

    memset(&astMtSample,'\0',sizeof(astMtSample));
    s32Ret = HAL_TOUCHPAD_ReadInputEventStatic(astMtSample);        //讀取設備的內容
    if (HI_SUCCESS != s32Ret)
    {
        MLOGD("read_input_event err\n");
        return HI_HAL_EINTER;
    }

    if (HI_TRUE == s_bHALTPUCHPADEnable)
    {
        pstInputData->s32ID = astMtSample[0].s32ID;
        pstInputData->u32Pressure = astMtSample[0].u32Pressure;
        pstInputData->s32X = astMtSample[0].s32X;
        pstInputData->s32Y = astMtSample[0].s32Y;
        pstInputData->u32TimeStamp = (astMtSample[0].tv.tv_sec) * 1000 + (astMtSample[0].tv.tv_usec) / 1000;
    }
    else
    {
        pstInputData->s32ID = 0;
        pstInputData->u32Pressure = 0;
        pstInputData->s32X = 0;
        pstInputData->s32Y = 0;
        pstInputData->u32TimeStamp = 0;
    }

    return HI_SUCCESS;
}

2.1.2 PDT_UI_StartApp

在ui_init.c中：

static HI_VOID * PDT_UI_StartApp(HI_VOID* pVoid)
{
    HI_S32 s32Ret;

    //創建應用程序
    s32Ret = HI_GV_App_Create("MainApp", (HIGV_HANDLE *)&s_AppHandle);
    if (HI_SUCCESS != s32Ret)
    {
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return NULL;
    }
    prctl(PR_SET_NAME, __FUNCTION__, 0, 0, 0);

    /*HI_GV_App_Start will not return until  HI_GV_App_Stop is called. */
    //啟動應用界面
    s32Ret = HI_GV_App_Start(s_AppHandle);
    HI_APPCOMM_CHECK_RETURN(s32Ret, NULL);

    return NULL;
}

3. HIGV架構

HiGV 是一個輕量級的 GUI 系統，主要是為芯片平台提供統一的輕量級、高效、易用的 GUI 解決方案。該系統采用分層機制實現，其中底層圖形庫依賴 SDK 中 HiGO 庫，而 HiGO 建立在基本的圖形驅動(FrameBuffer、芯片 2D 加速驅動、圖片編解碼等)之上，如圖 1-1 所示。

HiGV 吸取了優秀圖形系統設計思想，采用大量成熟的設計模式，使用了 XML 標記語言進行界面描述，具有統一高效的系統資源管理功能，並且 HiGV 還提供了豐富的控件。另外，為了解決易用性問題，還提供了快速可視化界面開發工具 HiGVBuilder 來幫助用戶進行界面開發。

架構中主要模塊的功能如下：

• HiGO：基本圖形組件，提供畫線、填充、搬移圖片等基本繪制接口。
• TDE：芯片 2D 加速驅動接口。
• FB：圖形層驅動接口。
• HiGV 主要模塊：詳見 3 “模塊詳解”。
• Xml2bin：xml 文件解析工具。
• HiGVBuilder：可視化的界面制作輔助工具

3.1 應用開發綜述

3.1.1 組成部分

通常，一個 HiGV 工程除了 main 函數外，還有其他幾個重要的組成部分：

• xml 界面描述文件
• 業務處理文件
• 界面使用到的資源文件。

UI 由若干個 HiGV 控件組成，這些控件可以使用 xml 文件描述，也可以通過調用HiGV 的接口創建。

通常使用 xml 文件描述界面及界面使用的資源數據，xml 描述界面方便易用，可以省略大量的控件創建代碼，HiGV 還會自動生成控件句柄，詳見 Xml 文件描述。也可以直接調用 HiGV 的接口創建界面控件，接口創建控件需要大量的變量放置這些控件的句柄以便於對這些控件進行操作，調用接口方式多用於動態創建或銷毀控件。

3.1.2 應用程序示例

如下以簡單的 Hello World 程序為例，通過該例子來說明 XML 文件、描述界面事件文
件、界面元素屬性及事件的關聯關系。
Hello World 程序要求為：

• 一個窗口上有一個“確定”按鈕和一個文本框，文本框默認內容為空。
• 當按確定按鈕時，把文本框內容設置為 Hello World!並顯示。

XML 描述文件為

<view
id = “hello_sample” <!—view name-->
onload = “”
unload = “”>
<window
id = “hello_sample” <!—window name-->
top = “0” <!—widget pos-->
left = “0”
width = “720”
height = “576”
normalskin = “commonpic_skin_colorkey” <!—normal skin-->
transparent = “no”
colorkey = “0xff0000ff”
isrelease = “yes”
opacity = “255”
winlevel = “0”
onshow = “hello_window_onshow”> <!—onshow call back-->
<button
id = “hello_button_ok” <!—ok button ID-->
top = “285”
left = “235”
width = “246”
height = “40”
normalskin = “commonpic_normalskin_button”
disableskin = “”
highlightskin = “”
activeskin = “commonpic_activeskin_button” <!—active state
skin-->
transparent = “no”
isrelease = “no”
text = “ID_STR_OK” <!—multi language ID-->
alignment = “hcenter|vcenter”
onclick = “hello_button_onclick”/> <!—onclick call back-->
<label
    id = “hello_label_helpinfo” <!—label ID-->
    top = “200”
    left = “235”
    width = “246”
    height = “50”
    normalskin = “common_skin_black”
    disableskin = “”
    highlightskin = “”
    activeskin = “”
    transparent = “yes”
    isrelease = “no”
    text = ""
    alignment = "hcenter|vcenter"/>
</window>
</view>

UI_XXX.c ：

/**Window onshow call back*/
HI_S32 hello_window_onshow (HI_HANDLE hWidget,HI_U32 wParam, HI_U32lParam)
{
    return HIGV_PROC_GOON;
}
/**OK button onclick call back*/
HI_S32 hello_button_onclick (HI_HANDLE hWidget,HI_U32 wParam,
HI_U32lParam)
{
    HI_S32 s32Ret;
    /**Change the label content*/
    s32Ret = HI_GV_Widget_SetText(hello_label_helpinfo, “Hello World!”);
    return HIGV_PROC_GOON;
}

Main.c：

#define SCREEN_WIDTH 1280
#define SCREEN_HEIGHT 720
#define PROJECT_ID hello_sample //from xml
HI_S32 main(HI_S32 argc, HI_CHAR *argv[])
{
    HI_S32 Ret;
    HI_S32 g_hApp ;
    /** The layer info, layer width is 1280 and height is 720. The pixel
    format is HIGO_PF_8888, Each pixel occupies 32 bits, and the A/R/G/B
    components each occupies 8 bits. Use Dual buffers supported .*/
    HIGO_LAYER_INFO_S LayerInfo = {SCREEN_WIDTH, SCREEN_HEIGHT,
    SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT,
    (HIGO_LAYER_FLUSHTYPE_E)(HIGO_LAYER_BUFFER_DOUBLE),
    HIGO_LAYER_DEFLICKER_AUTO,
    HIGO_PF_8888, HIGO_LAYER_HD_0};
    /**higv init*/
    Ret = HI_GV_Init();
    if (HI_SUCCESS != Ret)
    {
        return Ret;
    }
    /**Init parser module to parser binary file from xml.*/
    Ret = HI_GV_PARSER_Init();
    if (HI_SUCCESS != Ret)
    {
        printf("HI_GV_PARSER_Init failed! Return: %d\n",Ret);
        return Ret;
    }
    /**Load higv.bin*/
    Ret = HI_GV_PARSER_LoadFile("./higv.bin");
    if (HI_SUCCESS != Ret)
    {
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return Ret;
    }
    /**Create layer for draw graphics*/
    HI_HANDLE LAYER_0 = INVALID_HANDLE;
    Ret = HI_GV_Layer_Create(&LayerInfo, &LAYER_0);
    if (HI_SUCCESS != Ret)
    {
        printf("HI_GV_Layer_CreateEx failed! Return: %x \n",Ret);
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return Ret;
    }
    else
        printf("LAYER_0 create ok ...\n");
    /**Load view，PROJECT_ID is view ID from xml file. Create all child
    widget of PROJECT_ID.*/
    Ret = HI_GV_PARSER_LoadViewById(PROJECT_ID);
    if (HI_SUCCESS != Ret)
    {
        printf("HI_GV_PARSER_LoadViewById failed! Return: %x\n",Ret);
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return Ret;
    }
    /**Create HiGV app.*/
    Ret = HI_GV_App_Create("MainApp", (HI_HANDLE*)&g_hApp);
    if (HI_SUCCESS != Ret)  
    {
        printf("HI_GV_App_Create failed! Return: %d\n",Ret);
        HI_GV_Deinit();
        HI_GV_PARSER_Deinit();
        return Ret;
    }
    /**Show window.*/
    Ret = HI_GV_Widget_Show(PROJECT_ID);
    if(Ret !=0)
        printf("HI_GV_Widget_Show() failed ....: %d \n",Ret);
    Ret = HI_GV_Widget_Active(PROJECT_ID);
    if(Ret !=0)
        printf("HI_GV_Widget_Active() failed ....: %d \n",Ret);
    /*Start HiGV app*/
    HI_GV_App_Start(g_hApp);
    /** If the HiGV app over, the HI_GV_App_Start will be return.*/
    HI_GV_App_Destroy(g_hApp);
    HI_GV_PARSER_Deinit();
    HI_GV_App_Stop(g_hApp);
    return 0;
}

程序運行后，當按下“OK”鍵，產生 onclick 事件，導致調用 hello_button_onclick 函數，在該函數中修改文本框內容為“Hello World!”。如圖 1-2、圖 1-3 所示。