alarmoccur_main.c

C 代码C 代码C 代码C 代码C 代码C 代码C 代码C 代码C 代码C 代码

//********************************************************************
// Name:     MusicAPI.c
// 
// Copyright (C) Sitronix TECHNOLOGY INC.
// All rights reserved by Sitronix TECHNOLOGY INC.
//
// Project:    ST3110
// Author:      Terry Wu
// Begin Date:  2008/01/01
// Last update: 2008/04/01
// $Header: $
// Description:
//   music function
//   
//   
//********************************************************************



#include <intr6502.h>
#include "sys.h"
#include "img_position.h"
#include "ST3110_img_define.h"
#include "MusicPlayer.h"
#pragma codeseg(APP)

#define ALARM_STATE_BEGIN         0
#define ALARM_STATE_MUSIC_END     1
#define ALARM_STATE_RING_END      2
#define ALARM_STATE_MUSIC_RESUME  3

extern uint8 counter_2hz;
extern uint8 timer;
extern uint8 alarm_state,bg_music_state;
extern uint8 counter;
extern void _exit_alarm(void);
extern uint8 PlayAlarmRing(void);
uint8 _load_path(uint32 ram_path_adr);
void _AlarmStopRing(void);

void APP_MAIN(void)
{       
        
        if(API_OsCheckEventOccur(EVID_AUD_THD_RESPONSE))
        {
         API_OsReleaseEvent(EVID_AUD_THD_RESPONSE);
         switch(API_MusicGetThreadState())
         {
          case TS_STOP:
                if(alarm_state == ALARM_STATE_BEGIN) // when BG music end, to play alarm ring
                {
                 API_LcmPutSysImage(IMG_BACKGD,0,0);
                 if(PlayAlarmRing())
                  API_MusicSetRepeatMode(RM_REP_1);
                 alarm_state = ALARM_STATE_MUSIC_END;
                 API_OsPendEvent(EVID_BT_2HZ);
                }
                else if(alarm_state == ALARM_STATE_MUSIC_END) //when alarm ring end
                {
                 // do something after alarm stop
                 uint8 lrc_result,lrc_format;
                 alarm_state = ALARM_STATE_RING_END;
                 //resume background music
                 if(API_SysReadValue4B(RAM_SHARING_ADR,FRAME_NO_LL)>0)
                 {
                  if(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK) != TASKID_VIDEOPLAYER)
                  {
                        uint8 repeat;
                        
                        _load_path(RAM_MUS_PATH_ADR);
                        API_SysWriteValue2B(RAM_SHARING_ADR,CUR_FILE_L,API_SysReadValue2B(RAM_SHARING_ADR,B_SONG_FILE_L));
                        API_MusicSetFile(FF_MUSIC_FORM,API_SysReadValue2B(RAM_SHARING_ADR,B_SONG_FILE_L),FF_ID_AUTO);
                        API_MusicSetFrame(API_SysReadValue4B(RAM_SHARING_ADR,FRAME_NO_LL));
                        repeat = API_SysReadValue(RAM_SETTING_ADR,SET_REPEAT);
                        switch(repeat)
                        {
                         case 0: //play one 
                                 API_MusicSetRepeatMode(RM_REP_1);
                                 break;
                         case 1: //play all
                                 API_MusicSetRepeatMode(RM_REP_ALL);
                                 break;
                         case 2: //play random
                                 API_MusicSetRepeatMode(RM_RAND);
                                 break;
                        }
                        if(!API_MusicPlay(&lrc_result,&lrc_format))
                        {
                                //reload MPL lib
                                API_SysLoadMediaLib();
                                // set hardware volume
                                API_SysSetHardwareVolume(0,0); // DAC set 0
                                API_SysSetHardwareVolume(4,10); // Mixer set 10
                                //set mixer output
                                API_SysMixerOutputSelection(MIXER_DAC); 
                        }
                        if(bg_music_state == TS_PAUSE)
                         API_MusicVolumeAdjust(0);
                        API_SysWriteValue4B(RAM_SHARING_ADR,FRAME_NO_LL,0); //reset frame_no
                        API_OsPendEvent(EVID_AUD_THD_RESPONSE);
                        return;
                  }
                 }
                 _exit_alarm();
                }
                break;
          case TS_PLAY:
               if(alarm_state == ALARM_STATE_RING_END)
               {
                //API_LcmShowNumber(0,0,0,0);
                alarm_state = ALARM_STATE_MUSIC_RESUME;
                if(bg_music_state == TS_PAUSE)
                 API_MusicPause();
                else
                 _exit_alarm();
               }
               break;
          case TS_PAUSE:
                _exit_alarm();
                break;
         }         
         API_OsPendEvent(EVID_AUD_THD_RESPONSE);
        }
/*               
        if (API_OsCheckEventOccur(EVID_VID_THD_RESPONSE))
        {              
         API_OsReleaseEvent(EVID_VID_THD_RESPONSE);
         if( (API_VideoGetThreadState() == TS_STOP) )
         {
          API_LcmPutSysImage(IMG_BACKGD,0,0);
          API_OsPendEvent(EVID_BT_2HZ);
          if(PlayAlarmRing())
           API_MusicSetRepeatMode(RM_REP_1);
         }
         API_OsPendEvent(EVID_VID_THD_RESPONSE);                             
        } 
*/        
        if(API_OsCheckEventOccur(EVID_KEY_DOWN_60MS))
        {
         API_OsReleaseEvent(EVID_KEY_DOWN_60MS);
         _AlarmStopRing();
         API_OsPendEvent(EVID_KEY_DOWN_60MS);
        } 
        if(API_OsCheckEventOccur(EVID_KEY_KEEP_DOWN))
        {
         API_OsReleaseEvent(EVID_KEY_KEEP_DOWN);
         if(API_OsGetKeyId() == KEYID_MODE)
          API_OsSetCurrentTask(TASKID_POWEROFF);
         API_OsPendEvent(EVID_KEY_KEEP_DOWN);
        }             
                      
        if(API_OsCheckEventOccur(EVID_UPDATE_SD))
        {
         API_OsReleaseEvent(EVID_UPDATE_SD);
         API_OsSetCurrentTask(TASKID_CHANGESOURCE);                            
         API_OsPendEvent(EVID_UPDATE_SD);
        }
        
        if (API_OsCheckEventOccur(EVID_VBUS_PLUGIN))
        {              
         API_OsReleaseEvent(EVID_VBUS_PLUGIN);
         if(API_SysGetUSBSource() == VBUS_SRC_USB_ON_LINE)
         {
          API_SysWriteValue(RAM_SHARING_ADR,VBUS_STATE,VBUS_SRC_USB_ON_LINE);
          API_SysWriteValue(RAM_SHARING_ADR,LAST_TASK,TASKID_ALARMOCCUR);
          API_OsSetCurrentTask(TASKID_USBAPP);                          
         }
         else
         {
          API_SysWriteValue(RAM_SHARING_ADR,VBUS_STATE,VBUS_SRC_ADAPTER);
          //
         }
         API_OsPendEvent(EVID_VBUS_PLUGIN);
        }

        if(API_OsCheckEventOccur(EVID_VBUS_PLUGOUT))
        {      
         API_OsReleaseEvent(EVID_VBUS_PLUGOUT);
         API_SysWriteValue(RAM_SHARING_ADR,VBUS_STATE,VBUS_SRC_NONE);
         //API_LcmPutSysImage((API_SysGetVolLv()/4)+IMG_BATTERY_0,POS_MUSBRO_BATTERY_X,POS_MUSBRO_BATTERY_Y);
         API_OsPendEvent(EVID_VBUS_PLUGOUT);
        }   
        
        if(API_OsCheckEventOccur(EVID_UPDATE_BATVOL))
        {      
         uint8 bat_lv;
               
         API_OsReleaseEvent(EVID_UPDATE_BATVOL);
        
         bat_lv = API_SysGetVolLv();
         if(bat_lv < BATTERY_LV0)
         {
          API_OsSetCurrentTask(TASKID_POWEROFF);
         }
         API_OsPendEvent(EVID_UPDATE_BATVOL);
        }

        if(API_OsCheckEventOccur(EVID_BT_2HZ))
        {
         API_OsReleaseEvent(EVID_BT_2HZ);
         
         if(timer == 50)
          _AlarmStopRing();

         API_LcmPutSysImage(IMG_ALARM_0+counter_2hz,POS_ALARM_ICON_X,POS_ALARM_ICON_Y);
         if(counter_2hz == 3)
          counter_2hz = 0;
         else
          counter_2hz++;
         timer++;
         
         API_OsPendEvent(EVID_BT_2HZ);
        }
                              

                
}

void _AlarmStopRing(void)
{
          if( (API_MusicGetThreadState() == TS_PLAY) || (API_MusicGetThreadState() == TS_PAUSE))
          {
           if(alarm_state == ALARM_STATE_MUSIC_END)
           {
            uint8 repeat;
            repeat = API_SysReadValue(RAM_SETTING_ADR,SET_REPEAT);
            API_MusicStop();
            switch(repeat)
            {
                case 0: //play one 
                        API_MusicSetRepeatMode(RM_REP_1);
                        break;
                case 1: //play all
                        API_MusicSetRepeatMode(RM_REP_ALL);
                        break;
                case 2: //play random
                        API_MusicSetRepeatMode(RM_RAND);
                        break;
            }
           }
          }
}

void _exit_alarm(void)
{
          switch(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK))
          {
           case TASKID_PHOTOBROWSER:
                API_SysWriteValue(RAM_SHARING_ADR,PHO_PAINT_FLAG,1);
                break;
           case TASKID_MUSICBROWSER:
                API_SysWriteValue(RAM_SHARING_ADR,MUS_PAINT_FLAG,1);
                break;
           case TASKID_VIDEOBROWSER:
                API_SysWriteValue(RAM_SHARING_ADR,VID_PAINT_FLAG,1);
                break;
           case TASKID_MUSICPLAYER:
                API_SysWriteValue(RAM_SHARING_ADR,CHANGE_SONG,FALSE);
                break;
           case TASKID_PHOTOSHOW:
                _load_path(RAM_PHO_PATH_ADR);
                break;
          }
          if(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK) == TASKID_OPENING)
           API_OsSetCurrentTask(TASKID_POWEROFF);
          else         
           API_OsSetCurrentTask(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK));
}


//***************************************************************************
// Func:        uint8 _load_path(uint32 ram_path_adr)
// Input:       ram_path_adr : ram address
// Output:      result : TRUE
//                                         : FALSE
// Description: load path, assign CUR_FILE_L in RAM_SHARING_ADR and return result      
//
//***************************************************************************
uint8 _load_path(uint32 ram_path_adr)
{

 uint8 temp,result,root_order,i;
 uint16 cur_path,pre_path;
 
 root_order = API_SysReadValue(RAM_SHARING_ADR,ROOT_ORDER); 
 cur_path = 0;
 pre_path = 0;
 temp = 0;
 result = 0;
 
 //return to root
 while(root_order!=0)
 {
  API_FATExitFolder();
  API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,0); 
  root_order--;
 }
 API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,root_order);

 while((cur_path=API_SysReadValue2B(ram_path_adr,(temp++)*2 )) !=0 )
 {
   if(pre_path == 0) // first layer
   {
    pre_path = cur_path;
   } 
   else 
   {
    if(API_FATEnterFolder(pre_path))
    {
     if(root_order<8) //only record 8 order path
      API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,pre_path); 
     API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,++root_order);
     pre_path = cur_path;
    }
    else
    {
     //if wrong path  return to root
     while(root_order!=0)
     {
      API_FATExitFolder();
      API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,0); 
      root_order--;
     }
     API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,root_order);
     //clean record path and current path
     for(i=0;i<8;i++)
     {
       API_SysWriteValue2B(ram_path_adr,i*2,0);
       API_SysWriteValue2B(RAM_CUR_PATH_ADR,i*2,0);
     }
     return FALSE;
    }
   }
 }
 // cur_path=0, handle pre_path
 if(pre_path == 0) //no path, jump photo browser
 {
   result = FALSE;
 }
 else
 {
   result = TRUE;
   API_SysWriteValue2B(RAM_SHARING_ADR,CUR_FILE_L,pre_path);
 }
 return result;
}