usb_ap_main.c

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

        }
/*        
        if (API_OsCheckEventOccur(EVID_VID_THD_RESPONSE))
        {               
         API_OsReleaseEvent(EVID_VID_THD_RESPONSE);
         if( (API_VideoGetThreadState() == TS_STOP) )
          _usb_main_menu(selection);
         API_OsPendEvent(EVID_VID_THD_RESPONSE);                            
        }
*/        
                
}
//***************************************************************************
// Func:        void _usb_disconnect_pc(uint8 resume_flag)
// Input:       resume_flag     
//                           0 : only load fat lib
//                           1 : load fat lib and resume background music
//              state        
//                           USB_ITEM_PC        0
//                           USB_ITEM_CHARGE    1
// Output:      none
//
// Description: if it select connect to PC, it will reload FAT lib and return to default task. 
//              if it select charger, it will return to last task.
//
//***************************************************************************
void _usb_disconnect_pc(uint8 resume_flag, uint8 state)
{
          uint8 is_nand_sd;
          if(state == USB_ITEM_PC)
          {
                //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(API_SysSDCardDetect()) //SD 
           is_nand_sd = FAT_IS_SD;
          else //Nand flash
           is_nand_sd = FAT_IS_NAND;
          //avoid sd init FAT error
           if(!API_SysLoadFATLib(is_nand_sd))
            API_SysLoadFATLib(is_nand_sd);
           API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,0); 
           API_SysWriteValue(RAM_SHARING_ADR,IS_NAND_SD,is_nand_sd);


         if(resume_flag)
         {
           //resume background music, 
           // if frame_no != 0, resume
           // if frame_no == 0, do nothing
           if(API_SysReadValue4B(RAM_SHARING_ADR,FRAME_NO_LL)>0)
           {
            if(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK) != TASKID_VIDEOPLAYER)
            {
             uint8 lrc_result,lrc_format;
             _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));
             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
             //return;
            }
            else
             _return_last_task(state);
           }
         }
         else
          _return_last_task(state);
}
//***************************************************************************
// Func:        void _return_last_task(uint8 resume_flag)
// Input:       return_last_task 
//                                      USB_ITEM_PC     0
//                                      USB_ITEM_CHARGE 1
//                           0 : return to default task(A_Clock)
//                           1 : return to last task
// Output:      none
//
// Description: if it select connect to PC, it will return to default task. 
//              if it select charger, it will return to last task.
//
//***************************************************************************
void _return_last_task(uint8 state)
{
 if(state)
 {
          //return last task
          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;
           case TASKID_VIDEOPLAYER:
                _load_path(RAM_VID_PATH_ADR);
                break;
           case TASKID_CHANGESOURCE:
                // to avoid plug-in USB when SD CHANGE_SOURCE 
                API_SysWriteValue(RAM_SHARING_ADR,IS_NAND_SD,FAT_IS_NAND);
                break;
          }
          API_OsSetCurrentTask(API_SysReadValue(RAM_SHARING_ADR,LAST_TASK));
          API_SysWriteValue(RAM_SHARING_ADR,LAST_TASK,TASKID_USBAPP);
  
 }
 else
 {
          //reset frame_no
          API_SysWriteValue4B(RAM_SHARING_ADR,FRAME_NO_LL,0);
/*          
          // for photo browser
          API_SysWriteValue(RAM_SHARING_ADR,PHO_PAGE,0); 
          API_SysWriteValue(RAM_SHARING_ADR,PHO_CUR_SEL,0);
          API_SysWriteValue(RAM_SHARING_ADR,PHO_PRE_SEL,0);
          API_SysWriteValue(RAM_SHARING_ADR,PHO_PAINT_FLAG,TRUE);
     
          // paint photo browser BG
          API_SysWriteValue(RAM_SHARING_ADR,LAST_TASK,TASKID_USBAPP);
          API_OsSetCurrentTask(TASKID_PHOTOBROWSER);
*/          
          API_SysWriteValue(RAM_SHARING_ADR,LAST_TASK,TASKID_USBAPP);
          API_OsSetCurrentTask(TASKID_CLOCKACLOCK);
 
 }
}

//***************************************************************************
// 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;
}