musiceventapi.c

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

//********************************************************************
// Name:     PhotoBrowserAPI.c
// 
// Copyright (C) Sitronix TECHNOLOGY INC.
// All rights reserved by Sitronix TECHNOLOGY INC.
//
// Project:    ST3110
// Author:      Terry Wu
// Begin Date:  2008/05/19
// Last update: 
// $Header: $
// Description:
//   PhotoBrowser 
//   
//   
//********************************************************************

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



void _music_event_init(void);
void _music_sel_up(void);
void _music_sel_down(void);
void _music_sel_play(void);
void _music_last_page(void);
void _music_next_page(void);
void _music_update_cur_sel_item(void);
uint8 _load_path(uint32 ram_path_adr);
void _show_battery(void);
uint8 _get_battery_icon_index(void);

int16 file_curr_sel_item;
uint16 Folders,Files;
uint8 page,file_curr_sel_icon,file_pre_sel_icon;
uint8 root_order,file_repaint_flag,nand_sd_flag;
uint8 sfnPtr[13],lfnPtr[256];
uint16 total_page,total_item;
uint8 volume,repeat;//,battery;
uint8 music_flag;
uint8 slide_bat_lv_idx,cur_bat_lv_icon_idx;

//***************************************************************************
// Func:        void _music_event_init(void)
// Input:       none
// Output:      none
//
// Description: get parameter from RAM_SHARING_ADR and calculate "total_item" and "total_page"       
//
//***************************************************************************
void _music_event_init(void)
{
  //uint16 current_song_no;
  
  // init varible
  if( (API_MusicGetThreadState() == TS_PAUSE) || (API_MusicGetThreadState() == TS_PLAY) )
   music_flag=TRUE;
  else
   music_flag=FALSE;
  

  file_curr_sel_icon = API_SysReadValue(RAM_SHARING_ADR,MUS_CUR_SEL);       //0~9
  file_pre_sel_icon = API_SysReadValue(RAM_SHARING_ADR,MUS_PRE_SEL);        //0~9   
  file_repaint_flag = API_SysReadValue(RAM_SHARING_ADR,MUS_PAINT_FLAG);
  page = API_SysReadValue(RAM_SHARING_ADR,MUS_PAGE);                        //0~
  root_order = API_SysReadValue(RAM_SHARING_ADR,ROOT_ORDER);
  nand_sd_flag = API_SysReadValue(RAM_SHARING_ADR,IS_NAND_SD);
  volume = API_SysReadValue(RAM_SETTING_ADR,SET_VOLUME); // 0~16
  repeat = API_SysReadValue(RAM_SETTING_ADR,SET_REPEAT); //0~4
  

  API_FATGetItemAmountInFolder(&Folders,&Files,FF_MUSIC_FORM);

  if(root_order) // add return icon
   total_item = Folders+Files+1;
  else
   total_item = Folders+Files;

  if(music_flag) // add return music icon
   total_item = total_item +1;

  if( (total_item)%MUSBRO_ITEM != 0)
   total_page = (total_item/MUSBRO_ITEM) + 1;
  else 
   total_page = (total_item/MUSBRO_ITEM);
  
  _music_update_cur_sel_item();

  //get current battery voltage
  cur_bat_lv_icon_idx = _get_battery_icon_index();
  slide_bat_lv_idx = _get_battery_icon_index(); 
}

//***************************************************************************
// Func:        void _music_sel_up(void)
// Input:       none
// Output:      none
//
// Description: When press "UP" key, calculate "file_curr_sel_icon", "file_pre_sel_icon", "page" 
//              and "file_repaint_flag"
//
//***************************************************************************
void _music_sel_up(void)
{
        file_pre_sel_icon=file_curr_sel_icon;
        file_repaint_flag = 0;

        if(file_curr_sel_icon == 0)// last page
        {
         if(page>0) 
         {
          page--;
          file_curr_sel_icon = MUSBRO_ITEM-1;
          file_repaint_flag = 2;
         }
         else
         {
          if(total_item > 0)
          {
           page = total_page-1;
           file_curr_sel_icon = (total_item-1)%MUSBRO_ITEM;
          }
          else
          {
           page = 0;
           file_curr_sel_icon = 0;
          }
          
          file_repaint_flag = 2;
         }
        }
        else
        {
         file_curr_sel_icon--;
        }
        //update file_curr_sel_item
        _music_update_cur_sel_item();
        API_OsSetCurrentTask(TASKID_MUSICBROWSER);
}

//***************************************************************************
// Func:        void _music_sel_down(void)
// Input:       none
// Output:      none
//
// Description: When press "DOWN" key, calculate "file_curr_sel_icon", "file_pre_sel_icon", "page" 
//              and "file_repaint_flag"
//
//***************************************************************************
void _music_sel_down(void)
{
         
        file_pre_sel_icon=file_curr_sel_icon;
        file_repaint_flag = 0;
        
        if(file_curr_sel_item == (Folders+Files)) //go to first
        {
          page = 0;
          file_curr_sel_icon = 0;
          file_repaint_flag = 2;
        }
        else if(file_curr_sel_icon == MUSBRO_ITEM-1)
        {
         if(page < total_page-1)
         {
          page++;
          file_curr_sel_icon = 0;
          file_repaint_flag = 2;
         }
        }
        else
        {
         if( file_curr_sel_item < (int16)(Folders+Files) )
          file_curr_sel_icon++;
        }
        
        //update file_curr_sel_item
        _music_update_cur_sel_item();
        API_OsSetCurrentTask(TASKID_MUSICBROWSER);
}

//***************************************************************************
// Func:        void _photo_sel_play(void)
// Input:       none
// Output:      none
//
// Description: When press "PLAY" key, do appropriate operation
//
//***************************************************************************
void _music_sel_play(void)
{
        uint8 i;
        uint16 cur_item_amount;
        if(file_curr_sel_item == -1)
        {
           API_SysWriteValue(RAM_SHARING_ADR,CHANGE_SONG,FALSE);
           file_repaint_flag = 2;
           _load_path(RAM_MUS_PATH_ADR);
           API_OsSetCurrentTask(TASKID_MUSICPLAYER);
        }
        else if(file_curr_sel_item == 0)
        {
           API_FATExitFolder();
           API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,0); 
           API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,--root_order);

           file_repaint_flag = 2;
           cur_item_amount = API_SysReadValue2B(RAM_CUR_PATH_ADR,root_order*2);
           if(root_order) // add return last layer icon
            cur_item_amount++;
           if(music_flag) //add return music icon 
            cur_item_amount++;
           file_curr_sel_icon = (cur_item_amount-1)%MUSBRO_ITEM; 
           file_pre_sel_icon = 0;
           
           if((cur_item_amount%MUSBRO_ITEM)!=0 )
            page = (cur_item_amount/MUSBRO_ITEM);
           else
            page = (cur_item_amount/MUSBRO_ITEM)-1;
           API_OsSetCurrentTask(TASKID_MUSICBROWSER);
        }
        else if(file_curr_sel_item >=1 && file_curr_sel_item<=Folders)
        {
         API_FATEnterFolder(file_curr_sel_item);
         if(root_order<8) //only record 8 order path
          API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,file_curr_sel_item); 
         API_SysWriteValue(RAM_SHARING_ADR,ROOT_ORDER,++root_order);
         file_repaint_flag = 2;
         //file_pre_sel_icon = 0;
         file_curr_sel_icon = 0;
         page = 0;
         API_OsSetCurrentTask(TASKID_MUSICBROWSER);
        }
        else if( file_curr_sel_item > Folders && file_curr_sel_item<=Folders+Files)
        {
         if(root_order<8) //only record 8 order path
          API_SysWriteValue2B(RAM_CUR_PATH_ADR,root_order*2,(file_curr_sel_item-Folders));
         for(i=0;i<8;i++)
          API_SysWriteValue2B(RAM_MUS_PATH_ADR,i*2,API_SysReadValue2B(RAM_CUR_PATH_ADR,i*2));
          
         API_SysWriteValue2B(RAM_SHARING_ADR,CUR_FILE_L,(file_curr_sel_item-Folders) );
         API_SysWriteValue(RAM_SHARING_ADR,CHANGE_SONG,TRUE);
         file_repaint_flag = 2;
         file_pre_sel_icon = file_curr_sel_icon;
         file_curr_sel_icon = 0;
         page = 0;
         API_OsSetCurrentTask(TASKID_MUSICPLAYER);
        }
}

//***************************************************************************
// Func:        void _music_last_page(void)
// Input:       none
// Output:      none
//
// Description: jump to last page in music broswer
//
//***************************************************************************
void _music_last_page(void)
{
 uint8 curr_sel_num;
 
 curr_sel_num = file_curr_sel_item;

 if(music_flag)
  curr_sel_num++;
  
 if(root_order)
  curr_sel_num++; 
 
 if(curr_sel_num>MUSBRO_ITEM)
 {
  page--;
 }
 else //in page 0
 {
   if(file_curr_sel_icon == 0)
   {
          if(total_item > 0)
          {
           page = total_page-1;
           file_curr_sel_icon = (total_item-1)%MUSBRO_ITEM;
          }
          else
          {
           page = 0;
           file_curr_sel_icon = 0;
          }
   }
   else
   {
    file_curr_sel_icon = 0;
   }
 }
  
 file_repaint_flag = 2;
 _music_update_cur_sel_item();
 API_OsSetCurrentTask(TASKID_MUSICBROWSER);
}

//***************************************************************************
// Func:        void _music_last_page(void)
// Input:       none
// Output:      none
//
// Description: jump to next page in music broswer
//
//***************************************************************************
void _music_next_page(void)
{
 if(file_curr_sel_item == (Folders+Files)) //go to first
 {
  page = 0;
  file_curr_sel_icon = 0;
 }
 else if(file_curr_sel_item+MUSBRO_ITEM > Folders+Files) //go to last one
 {
  if(page == total_page-2)
   page++;
  file_curr_sel_icon = (total_item-1)%MUSBRO_ITEM;
 }
 else
 {
  page++;
 }
 file_repaint_flag = 2;
 _music_update_cur_sel_item();
 API_OsSetCurrentTask(TASKID_MUSICBROWSER);
}

//***************************************************************************
// Func:        void _photo_update_sel_item(void)
// Input:       none
// Output:      none
//
// Description: update "file_curr_sel_item" by "page" and "file_curr_sel_icon"
//
//***************************************************************************
void _music_update_cur_sel_item(void)
{
  //caculate file_curr_paint_item
  if(total_item > 0)
  {
   if(root_order) //after second layer
    file_curr_sel_item = (page*MUSBRO_ITEM) + file_curr_sel_icon; //item number is from 0
   else //root
    file_curr_sel_item = (page*MUSBRO_ITEM) + file_curr_sel_icon+1; //item number is from 1
  }
  else
  {
   file_curr_sel_item = 0;
  }


   if(music_flag)
    file_curr_sel_item = file_curr_sel_item -1;
   
   //when music is playing and in root //special case
   if(music_flag && (root_order == 0) && (file_curr_sel_item == 0))
    file_curr_sel_item = -1;

 if(file_curr_sel_item > (int16)(Folders+Files))
 {
   #if DEBUG
    API_LcmSetStringLenth(35);   
    API_LcmShowString("calculate file_curr_sel_item error",0,0);
   #endif
 } 
}

//***************************************************************************
// 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;
}
void _show_battery(void)
{
           API_LcmPutSysImage(IMG_BATTERY_0+_get_battery_icon_index(),POS_MUSBRO_BATTERY_X,POS_MUSBRO_BATTERY_Y);  
}

uint8 _get_battery_icon_index(void)
{
           uint8 bat_lv_icon_index;
           uint8 bat_lv;
         
           bat_lv = API_SysGetVolLv();
           if(BATTERY_LV4 <= bat_lv)                                // > LV4
            bat_lv_icon_index = 4; 
           else if( BATTERY_LV3 <= bat_lv && bat_lv < BATTERY_LV4)  //  LV3<=  <LV4
            bat_lv_icon_index = 3;         
           else if( BATTERY_LV2 <= bat_lv && bat_lv < BATTERY_LV3)  //  LV2<=  <LV3
            bat_lv_icon_index = 2;         
           else if( BATTERY_LV1 <= bat_lv && bat_lv < BATTERY_LV2)  //  LV1<=  <LV2
            bat_lv_icon_index = 1;         
           else if( BATTERY_LV0 <= bat_lv && bat_lv < BATTERY_LV1)  //  LV0<=  <LV1
            bat_lv_icon_index = 0;
           
           return bat_lv_icon_index;
}