mfw_kbd.c

是一个手机功能的模拟程序

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : kbdCreate          |
+--------------------------------------------------------------------+

  PURPOSE : create keyboard control

*/

MfwHnd kbdCreate (MfwHnd w, MfwEvt e, MfwCb f)
{
    MfwHdr *hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
    MfwKbd *kbd = (MfwKbd *) mfwAlloc(sizeof(MfwKbd));

    if(!hdr || !kbd)
        return 0;

    kbd->map = e;
    kbd->key = 0;
    kbd->handler = f;

    hdr->data = kbd;
    hdr->type = MfwTypKbd;

    return mfwInsert(w,hdr);
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : kbdDelete          |
+--------------------------------------------------------------------+

  PURPOSE : delete keyboard control

*/

MfwRes kbdDelete (MfwHnd h)
{
    MfwRes res;

    if(!h)
        return MfwResIllHnd;

    res = (mfwRemove(h)) ? MfwResOk : MfwResIllHnd;

    mfwFree(((MfwHdr *) h)->data,sizeof(MfwKbd));
    mfwFree(h,sizeof(MfwHdr));

    return res;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : sigExec            |
+--------------------------------------------------------------------+

  PURPOSE : execute keyboard signal
            if the registered set of keys match the currently
            pressed key, the event handler is called, if the
            registered flags match the current flags according
            to the following table:
            M: Make/Break (key release events wanted)
            L: Long press event (timeout set via kbdTime())
            A: Auto repeat event (timing defined via kbdTime())

                                            M 0 0 0 0 1 1 1 1
            current event flags ---------   L 0 0 0 0 0 0 1 1
                                            A 0 0 0 0 0 1 0 1
                                      M L A .................
                                      0 0 0 . 0 0 0 0 1 0 0 0
                                      0 0 1 . 0 0 0 0 1 1 0 1
            registered                0 1 0 . 0 0 0 0 0 0 1 1
            event       -----------   0 1 1 . 0 0 0 0 0 1 1 1
            flags                     1 0 0 . 1 1 1 1 1 0 0 0
                                      1 0 1 . 1 1 1 1 1 1 0 1
                                      1 1 0 . 1 1 1 1 0 0 1 1
                                      1 1 1 . 1 1 1 1 0 1 1 1

*/

static int sigExec (MfwHdr *curElem, U32 map, U8 key)
{
    MfwKbd *kc;

    while(curElem)
    {
        if(curElem->type == MfwTypKbd)
        {
            kc = curElem->data;
            if(kc->map & map & ~KEY_FLAGS)
            {                           /* keys match               */
                kc->code = key;         /* set current key code     */
                if(map & KEY_MAKE)
                {
                    kc->key |= map;     /* set key in control block */
                }
                else
                {
                    kc->key &= ~map;    /* del key in control block */
                    kc->key &= ~KEY_MAKE; /* del make/break flag    */
                }
                if((KEY_MAKE & ~map & kc->map) ||
                   (KEY_MAKE & map &&
                    ((KEY_LONG & map & kc->map)        ||
                     (!(KEY_LONG & kc->map)
                      && (KEY_AUTO & kc->map & map)) ||
                     (!(KEY_LONG & map)
                      && !(KEY_AUTO & map)
                      && !(KEY_LONG & kc->map))      ||
                     (!(KEY_LONG & map)
                      && (KEY_AUTO & map)
                      && (KEY_AUTO & kc->map)))))
                {
                    if(kc->handler)    /* handler valid            */
                    {
                        // PATCH LE 06.06.00
                        // store current mfw elem
                        current_mfw_elem = curElem;
                        // END PATCH LE 06.06.00
                        if((*(kc->handler))(map,kc))
                            return 1;   /* event consumed           */
                    }
                }
            }
        }
        curElem = curElem->next;
    }

    return 1;// old is "return 0"change zy 10/10 don't sent this things to above level
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : sigDistribute      |
+--------------------------------------------------------------------+

  PURPOSE : distribute keyboard event

*/

static void sigDistribute (U32 map, U8 key)
{
    int res = 0;

    if(doAlways)
        if(doAlways(map,(void*) -1))
            return;                     /* event consumed           */

    if(mfwSignallingMethod == 0)
    {
        if(mfwFocus)
            res = sigExec(mfwFocus,map,key);
        if(!res && mfwRoot)
            res = sigExec(mfwRoot,map,key);
    }
    else
    {
        MfwHdr *h = mfwFocus;
        if(!h)
            h = mfwRoot;
        while(h)
        {
            if(res = sigExec(h,map,key))
                break;
            if(h == mfwRoot)
                break;
            h = mfwParent(mfwParent(h));
            if(h)
                h = ((MfwWin *)(h->data))->elems;
        }
        if(!res && mfwRoot && h != mfwRoot)
            res = sigExec(mfwRoot,map,key);
    }

    if(doAlways)
        doAlways(map,(void*) res);

    return;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : kbdSignal          |
+--------------------------------------------------------------------+

  PURPOSE : keyboard event (called by driver/PEI)

*/

void kbdSignal (char make, char key)
{
    U32 map;
    UBYTE temp;
    if(key < 0 || key > KCD_MAX)
        return;
    /*NM, p006a
    temp = dspl_Enable(0);
    NM, p006a end*/
    /*
          if((key != 22)&&(key !=27 )){
              //zym added 10/18
            if(!g_kpdnum){
                g_kpdtim = 1;
                StartSecTime();
            }
            g_kpdnum++;
            MmiTrace("kpd_key_handler");
            MmiTraceInt(g_kpdnum);
            if(g_kpdnum>PRENUMPERSEC*2){
                  return ;
            }
            }
    
    */
    map = 1L << key;
    MmiTrace("zym:kbdSignal");
    MmiTraceInt(key);
    MmiTraceInt(drvpara.hallstatusflag);

    if(key == KCD_F4)
    {
        if(drvpara.hallstatusflag ==1)
        {
            ColorLCD_Init(0);
            r2d_refresh();
            // r2d_check_and_send_event_New(r2d_g_lcd_gc);
            LCD_ON();
            LedLightnessAdjust(16);//zy 08/14
            timStart(gtVibator);
            Backlight_ON();

            /*
  
             //set the GPIO0,1,3 ,hxl add 20020929---------------------------------
              *((volatile UINT16 *)(0xfffef008))&=0xfffe; 
              *((volatile UINT16 *)(0xfffe4804))&=0xfffe;  
  
  
              *((volatile UINT16 *)(0xfffef008))&=0xfffd; 
              *((volatile UINT16 *)(0xfffe4804))&=0xfffd;  
  
              *((volatile UINT16 *)(0xfffef008))&=0xfbff; 
              *((volatile UINT16 *)(0xfffe4804))&=0xfff7;  
  
              //open KBD
              *((volatile UINT16 *)(0xfffe4818))&=0xfffd;
              //open LED
              SPIWrite_ABB_Register(1,24,0x0003);
              //end of hxl add 20020929---------------
              */


        }
        else
        {

            Sleep_Or_Quality(1);
            LCD_OFF();
            Backlight_OFF();
            /*
            //set the GPIO0,1,3 to input mode,for power saving 20020929---------------
             *((volatile UINT16 *)(0xfffef008))&=0xfffd; // GPIO1，功放
             *((volatile UINT16 *)(0xfffe4804))|=0x0002;  
 
             *((volatile UINT16 *)(0xfffef008))&=0xfffe; //GPIO0,串口
             *((volatile UINT16 *)(0xfffe4804))|=0x0001; 
 
             *((volatile UINT16 *)(0xfffef008))&=0xfbff; //GPIO3，串口
             *((volatile UINT16 *)(0xfffe4804))|=0x0008; 
 
             //close KBD
             *((volatile UINT16 *)(0xfffe4818))|=0x0002;
             //close LED
             SPIWrite_ABB_Register(1,24,0x000);
             //end of hxl add for power saving 20020929-------------------------------
             */

        }
        AI_UnmaskIT(2);

        //  	return ;
    }

    if((drvpara.hallstatusflag==0)&&((key != KCD_F4)&&(key != KCD_ABC)))  ///zym modified charging virtual key must send 
        return;//zy 11/25 lock all key when hall is closed


    #if defined (WIN32)
    if(make)
    #else
    //kk    if (!make) //kk only needed for asample board
    if(make)
    #endif
    {
        /* NM, p006b
        old : refresh the LCD for keypress and keyrelease
        new: update only on keypress

        there was a unknown effect (doesnt show the '0')
        so this is the reason to add the 'sigDistribute' in every
        statement.

        NM, p006b end */

        ///	temp = dspl_Enable(0);
        map |= KEY_MAKE;
        curMap = map;
        curKey = key;
        if((key != KCD_ABC)&&(key != KCD_F4))
        {
            if((!MorethanMaxPressKeyNum(3))&&(r2d_g_event_was_sent == 0))
            {
                MMIActionKeyPress();///zym added
                timStart(&timLongH);
                timAuto.time = valAuto;
                /*NM, p007a*/
                if(valAuto)
                    timStart(&timAutoH);
            }
        }
        /*NM, p007a end*/

        /*NM, p006c*/
        sigDistribute(map,key);
        ///  		dspl_Enable(temp); 
        /*NM, p006c end*/
    }
    else
    {
        map &= ~KEY_MAKE;
        curMap = map; //ES!!
        curKey = key; //ES!!
        if((!MorethanMaxPressKeyNum(3))&&(r2d_g_event_was_sent == 0))
        {
            timStop(&timLongH);
            /*NM, p007b*/
            if(valAuto)
                timStop(&timAutoH);
            /*NM, p007b end*/
        }
        /*NM, p006d */
        sigDistribute(map,key);
        /*NM, p006d end */
    }

    /*NM, p006e 
    sigDistribute(map,key); 
    dspl_Enable(temp); 
    NM, p006e end*/


    return;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : toLong             |
+--------------------------------------------------------------------+

  PURPOSE : long press timeout handler

*/

static int toLong (U32 t, void *h)
{
    curMap |= KEY_LONG;
    sigDistribute(curMap,curKey);

    return 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : toAuto             |
+--------------------------------------------------------------------+

  PURPOSE : auto repeat timeout handler

*/

static int toAuto (U32 t, void *h)
{
    curMap |= KEY_AUTO;
    sigDistribute(curMap,curKey);
    timAuto.time = valRepeat;
    /* NM p007c*/
    if(valRepeat)
        timStart(&timAutoH);
    /* NM p007c end*/
    return 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_KBD            |
| STATE   : code                        ROUTINE : kbdCommand         |
+--------------------------------------------------------------------+

  PURPOSE : handle mfw windows command

*/

static int kbdCommand (U32 cmd, void *h)
{
    switch(cmd)
    {
    case MfwCmdDelete:              /* delete me                */
        if(!h)
            return 0;
        kbdDelete(h);
        return 1;
    default:
        break;
    }

    return 0;
}

int  MorethanMaxPressKeyNum(int num)
{
    MmiTrace("MorethanMaxPressKeyNum");
    MmiTraceInt(g_keypadnum);   
    if(g_keypadnum > num)
        return 1;
    return 0;
}
#endif