meta_com.cpp

MTK手机开发工具软件,可以从电脑上下载文件到手机存储空间.在软件开发过程中,当想利用MTK系统存储空间来存储一些数据文件时,可以通过此方法实现.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop


#include "DOWNLOAD.H"

#include "Meta_com.h"
#include "main.h"
#include "OK_Wnd.h"
#pragma package(smart_init)

static AUTH_HANDLE_T g_AUTH_HANDLE = NULL;
static BBCHIP_TYPE g_nBBChipType = AUTO_DETECT_BBCHIP;
static EXT_CLOCK g_nExtClock = AUTO_DETECT_EXT_CLOCK;		// User declarations
static UART_BAUDRATE g_BaudRate;

static int g_stopflag;


void Meta_com_SetBaudRate( unsigned int baud )
{
    switch( baud )
    {
		case 921600:
			g_BaudRate = UART_BAUD_921600;
			break;
		case 460800:  // 2002.3.28 High Speed
			g_BaudRate = UART_BAUD_460800;
			break;
		case 230400:  // 2002.3.28 High Speed
			g_BaudRate = UART_BAUD_230400;
			break;
		case 115200:
			g_BaudRate = UART_BAUD_115200;
			break;
		case 57600:
			g_BaudRate = UART_BAUD_57600;
			break;
		case 38400:
			g_BaudRate = UART_BAUD_38400;
			break;
		case 19200:
			g_BaudRate = UART_BAUD_19200;
			break;
		case 9600:
			g_BaudRate = UART_BAUD_9600;
			break;
		default:
			g_BaudRate = UART_BAUD_19200;
			break;
    }
}

static int __stdcall cb_boot_meta_in_brom_stage(unsigned int brom_handle, HANDLE hCOM, void *usr_arg)
{
    Meta_com *t=(Meta_com *)usr_arg;
	// start fake progress
    return 0;
}

static int __stdcall cbFATProgress(unsigned char percent, int sent_bytes, int total_bytes, const short token, void *usr_arg)
{
    Meta_com *t=(Meta_com *)usr_arg;

    t->m_nPercent = percent;
    t->m_nSentBytes = sent_bytes;
    t->m_nTotalBytes = total_bytes;

    t->SyncUpdateProgress();

    return 0;
}



//---------------------------------------------------------------------------

//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall Meta_com::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------

__fastcall Meta_com::Meta_com(bool CreateSuspended)
        : TThread(CreateSuspended)
{
        m_bIsPreTerminate = false;
        m_nStatus = MC_STATE_INIT;
}


//---------------------------------------------------------------------------
void __fastcall Meta_com::Execute()
{
    //---- Place thread code here ----
    META_RESULT MetaResult;
    DownloadFileList::iterator	iter;
    if( iter == NULL )
    {
        Terminate();
    }

    do
    {
        if(g_stopflag == BOOT_STOP)
            break;

        switch( m_nStatus )
        {
        case    MC_STATE_INIT:
            if( true == EnterMETA() )
            {
                MetaResult = META_FAT_GetDiskInfo( 'C', &m_fatDiskInfo, NULL );
                if( MetaResult != META_SUCCESS )
                {
                    asMsg = "Get Fat infomation error!";
                    Synchronize( ShowMessage );
                    m_bIsPreTerminate = true;
                    break;
                }

                iter = MainForm->m_FilesList.begin();
                m_nStatus = MC_STATE_IDLE;
            }
            else
            {
                //Sleep( 3000 );
                //asMsg = "Can't connected target!";
                //Synchronize( ShowMessage );
                m_bIsPreTerminate = true;
            }
            break;
        case    MC_STATE_TRAN:
            {
                int fs_handle;
                FAT_FILE_INFO_REQ_T req;
                req.m_cDriveLetter = 'C';
                req.m_pcfilepath = "DCTC\\";
                MetaResult = META_FAT_CheckEnoughSpace(&req);
                if( MetaResult != META_SUCCESS )
                {
                    asMsg = "Check Enough Space Error!";
                    Synchronize( ShowMessage );
                    m_bIsPreTerminate = true;
                    break;
                }

                AnsiString as_FATFilePathName("C:\\DCTC\\" + iter->m_AliasName);
                asMsg = as_FATFilePathName;
                Synchronize( UpdateFilename );

                MetaResult = META_FAT_Open( as_FATFilePathName.c_str(), FAT_OPEN_WRITE, &fs_handle, NULL );
                if( MetaResult != META_SUCCESS )
                {
                    asMsg = "FAT Open failed !";
                    Synchronize( ShowMessage );
                    m_bIsPreTerminate = true;
                    break;
                }

                MetaResult = META_FAT_Write_By_File( fs_handle, iter->m_Filepath.c_str(), cbFATProgress, this, NULL );
                if (MetaResult != META_SUCCESS)
                {
                    //Set_ErrorString(MetaResult);
                    MetaResult = META_FAT_Close( &fs_handle, NULL );
                    if (MetaResult != META_TIMEOUT)
                    {
                        asMsg = "FAT: Write data failed!";
                        Synchronize( ShowMessage );
                    }
                    else
                    {
                        asMsg = "FAT: Write data timeout!";
                        Synchronize( ShowMessage );
                    }
                    m_bIsPreTerminate = true;
                    break;
                }

                MetaResult = META_FAT_Close( &fs_handle, NULL );
                if (MetaResult != META_SUCCESS)
                {
                    //Set_ErrorString(MetaResult);
                    if (MetaResult != META_TIMEOUT)
                    {
                        //Confirm(METAAPP_FAIL);
                    }
                    else
                    {
                        //Confirm(METAAPP_TIMEOUT);
                    }
                    m_bIsPreTerminate = true;
                }

                iter ++;
                m_nStatus = MC_STATE_IDLE;
            }
            break;
        case    MC_STATE_IDLE:
            while( iter != MainForm->m_FilesList.end() )
            {
                if( iter->m_Enable )
                {
                    Synchronize( InitProgress );
                    m_nStatus = MC_STATE_TRAN;
                    break;
                }

                iter ++;
            }

            if( m_nStatus == MC_STATE_IDLE )
            {
                Synchronize( FinisthMessage );
                m_bIsPreTerminate = true;
            }
        default:
            break;
        }
    }while( (m_bIsPreTerminate == false) );

    if( m_nStatus != MC_STATE_INIT )
    {
        ExitMeta();
        m_nStatus = MC_STATE_INIT;
    }

    Terminate();
}
//---------------------------------------------------------------------------



bool __fastcall Meta_com::EnterMETA( void )
{

	static 	META_COMM_BAUDRATE  allow_baudrate[11]={
			META_BAUD115200,
			META_BAUD230400,
			META_BAUD460800,
			META_BAUD921600,
			META_BAUD_END,
			META_BAUD_END,
			META_BAUD_END,
			META_BAUD_END,
			META_BAUD_END,
			META_BAUD_END,
			META_BAUD_END
		};

	META_RESULT         meta_ret;
	META_Connect_Req	meta_req;
	META_Connect_Report	meta_report;

	meta_req.com_port = MainForm->m_nComPort;
	memcpy(meta_req.baudrate, allow_baudrate, sizeof(meta_req.baudrate));
	meta_req.flowctrl = META_SW_FLOWCTRL;
	meta_req.ms_connect_timeout = 40000;
	meta_req.boot_meta_arg.m_bbchip_type = g_nBBChipType;
	meta_req.boot_meta_arg.m_ext_clock = g_nExtClock;
	meta_req.boot_meta_arg.m_ms_boot_timeout = BOOT_INFINITE;
	meta_req.boot_meta_arg.m_max_start_cmd_retry_count = 1;
	meta_req.boot_meta_arg.m_cb_in_brom_stage = NULL;   // cb_boot_meta_in_brom_stage;
	meta_req.boot_meta_arg.m_cb_in_brom_stage_arg = NULL;   // this;
	meta_req.boot_meta_arg.m_speedup_brom_baudrate = _TRUE;
	// WM_BROM_READY_TO_POWER_ON_TGT
	meta_req.boot_meta_arg.m_ready_power_on_wnd_handle	= NULL;
	meta_req.boot_meta_arg.m_ready_power_on_wparam		= NULL;
	meta_req.boot_meta_arg.m_ready_power_on_lparam		= NULL;
	// serial link authentication arg
	meta_req.boot_meta_arg.m_auth_handle = g_AUTH_HANDLE;
	meta_req.boot_meta_arg.m_cb_sla_challenge         = SLA_Challenge;
	meta_req.boot_meta_arg.m_cb_sla_challenge_arg     = this;
	meta_req.boot_meta_arg.m_cb_sla_challenge_end     = SLA_Challenge_END;
	meta_req.boot_meta_arg.m_cb_sla_challenge_end_arg = this;

	// reset fake progress
	//progress_hint = "Reset NVRAM to factory default setting ...";
	//progress_forecolor = clGreen;
	//Synchronize(ResetFakeProgress);

	if( META_SUCCESS != (meta_ret=META_ConnectWithTarget(&meta_req, &g_stopflag, &meta_report)) ) {
		// stop fake progress 
		//Synchronize(StopFakeProgress);
		asMsg = "META_ConnectWithTarget(): ERROR: " + AnsiString(META_GetErrorString(meta_ret));
		Synchronize(ShowMessage);
		return false;
	}
    // todo : down load files here

    switch( meta_report.final_baudrate )
    {
    case META_BAUD2400:
         m_nBaudRate = 2400;
         break;
	case META_BAUD4800:
         m_nBaudRate = 4800;
         break;
	case META_BAUD9600:
         m_nBaudRate = 9600;
         break;
	case META_BAUD14400:
         m_nBaudRate = 14400;
         break;
	case META_BAUD19200:
         m_nBaudRate = 19200;
         break;
	case META_BAUD57600:
         m_nBaudRate = 57600;
         break;
	case META_BAUD115200:
         m_nBaudRate = 115200;
         break;
	case META_BAUD230400:
         m_nBaudRate = 230400;
         break;
	case META_BAUD460800:
         m_nBaudRate = 460800;
         break;
    case META_BAUD921600:
         m_nBaudRate = 921600;
         break;
    default:
         break;
    }
    Synchronize( UpdateBaudrate );

	//META_DisconnectWithTarget();
	// finish fake progress
	//Synchronize(FinishFakeProgress);
	return true;
}

bool __fastcall Meta_com::ExitMeta(void)
{
    //TODO: Add your source code here
    META_DisconnectWithTarget();

    return true;
}

void __fastcall Meta_com::ShowMessage(void)
{
    //TODO: Add your source code here
    MainForm->EnableCtrls();

    ::ShowMessage( asMsg );
}

void __fastcall Meta_com::SyncUpdateProgress(void)
{
    //TODO: Add your source code here
    Synchronize(UpdateProgress);
}

void __fastcall Meta_com::UpdateProgress(void)
{
    //TODO: Add your source code here
    MainForm->CGauge1->Progress = m_nPercent;

    unsigned int Bps = m_nSentBytes / MainForm->m_nProgressTimeSec;
    if( Bps > 1024 )
    {
        unsigned int KBps = Bps / 1024;
        MainForm->StatusBar1->Panels->Items[0]->Text.printf( "%d KBps", KBps );
    }
    else
    {
        MainForm->StatusBar1->Panels->Items[0]->Text.printf( "%d Bps", Bps );
    }
}

void __fastcall Meta_com::InitProgress(void)
{
    //TODO: Add your source code here

    m_nPercent = 0;
    m_nSentBytes = 0;
    m_nTotalBytes = 0;

    MainForm->m_nProgressTimeSec = 0;
    MainForm->CGauge1->Progress = 0;
    MainForm->StatusBar1->Panels->Items[0]->Text = "0 Bps";
}

void __fastcall Meta_com::FinisthMessage(void)
{
    //TODO: Add your source code here
    MainForm->EnableCtrls();
    
    Form_OK->Visible = true;
}

void __fastcall Meta_com::UpdateFilename(void)
{
    //TODO: Add your source code here
    MainForm->StatusBar1->Panels->Items[3]->Text = "File: "+asMsg;
}

void __fastcall Meta_com::UpdateBaudrate(void)
{
    //TODO: Add your source code here
    MainForm->m_nBaudRate = m_nBaudRate;
    MainForm->StatusBar1->Panels->Items[2]->Text = IntToStr( m_nBaudRate ) + " bps";
}