如何实现手机中应用程序的开机自启动,附源代码

本文介绍如何使用Symbian系统的Recognizer实现应用程序的开机自启动功能,并提供了详细的代码示例。通过设置特定的MIME类型和文件扩展名,Recognizer能够识别特定的数据并触发自启动过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

根据以往Symbian设计的经验,Recognizer将被用来识别与文件绑定的MIME类型。这是用来处理特殊类型数据的步骤之一。相关知识可以参考Nokia那篇著名的《guide for application developer on document handler》文档,在symbian sdk安装目录下面的Series60Doc目录下面可以找到他。
         Recognizer也能够用来实现应用程序的开机自启动,当然这不是Recognizer的本意。但是,很危险的是,如果recognizer出了问题,手机将无法正常启动,而且你必须要重新到当地的Nokia客服部门重新刷机。
        下面的代码是用于EZBoot应用的,这些代码本身有很好的说明,所以我不再详细解释。
        注意,出现在头文件和mmp文件中的0x101Fxxxx这个值需要用你自己项目的UID替换。

头文件源码:

//
//

//                              EZ-Boot
//                         

//
//
                       Boot & Recognizer Module
//                    by NewLC (http://www.newlc.com)

//
//
 File         : ezrecog.h
//
 Compatibility: Symbian OS v6.1
//
 History:
//
   2003.07.26: EBS : Creation
//
   2003.08.12: EBS : Integration in EZBoot
//
   2003.09.01: EBS : Add boot file recognition
//   2003.10.28: EBS : Cleanup and comment

//

#include 
<apmrec.h> // CApaDataREcognizerType

#define KUidRecog 0x1xxxxxxx // Use your own value here !!!

class CRecog : public  CApaDataRecognizerType
{
public

        CRecog();
        TUint PreferredBufSize();
        TDataType SupportedDataTypeL(TInt aIndex) 
const
;
        
static void
 BootUp();
        
static TInt BootUpKick(TAny *
aParam);
        
static void
 BootUpKickL();
        
private
:
        
void DoRecognizeL(const TDesC& aName, const TDesC8&
 aBuffer);
        TBool HeaderRecognized(
const TDesC8&
 aBuf);
        TBool NameRecognized(
const TDesC&
 aName);
};

 

实现的源代码:

//
//
//                              EZ-Boot
//                          
//
//                       Boot & Recognizer Module
//                     by NewLC ( http://www.newlc.com )
//
//  File         : ezrecog.cpp
//  Compatibility: Symbian OS v6.1
//  History:
//    2003.07.26: EBS : Creation
//    2003.08.12: EBS : Integration in EZBoot
//    2003.09.01: EBS : Add boot file recognition
//    2003.10.28: EBS : Cleanup and comment
//

#include 
< e32std.h >
#include 
< e32base.h >
#include 
< e32def.h >
#include 
< f32file.h >
#include 
< apacmdln.h >
#include 
< apgcli.h >
#include 
< apmrec.h >  
#include 
< apmstd.h >
#include 
" ezrecog.h "

//
//
//  Recognition Definitions
//
/// //

//  The MIME Type that will be recognized
_LIT8(KEzbMimeType, " text/vnd.newlc.ezboot " );

//  The file extension that shall be used by data we are recognizing
_LIT(KEzbFileExtension, " .boot " );
 
//  The data header that identifies EZBoot data
_LIT8(KEzbDataHeader, " EZBoot: " );

//  The priority of the recognizer, can be EHigh, ENormal, ELow
#define  KEzRecognizerPriority CApaDataRecognizerType::ENormal

//  The size of the data buffer that will be passed to the recognizer
//  so that it performs the recognition
#define  KEzRecognizerBufferSize 7

//  The recognizer UID
const  TUid KUidEzBoot = {KUidRecog};


//
//
//  Boot Definitions
//
/// //

//  The application we want to boot (here the EZBoot server)
_LIT(KEzBootExe, " \\system\\programs\\ezboot\\ezbootsrv.exe " );

//  The thread name that will used to launch the above EXE
_LIT(KBootUpThreadName, " EzBootThr " );

//
///  DLL entry point.
///  \param aReason can be ignored.
///  \return Always KErrNone
/// //
GLDEF_C TInt E32Dll(TDllReason  /* aReason */ )
{
   
return (KErrNone);
}

//
///  Recognizer instanciation. This function MUST be the first one defined 
///  for the recognizer.
///  \return a pointer on a new allocated recognizer instance
//
EXPORT_C CApaDataRecognizerType  * CreateRecognizer()
{
   
//  Create a recognizer instance
   CApaDataRecognizerType  * me  =   new  CRecog();
   
   
//  Start all the boot code under a trap harness
   
//  This is pure boot code and has (normally) nothing to do 
   
//  in a recognizer
   CRecog::BootUp();
   
   
return (me);
}

//
///  Recognizer Constructor. 
///  Initialise the internal data member iCountDataTypes with the number of 
///  MIME types that will be recognized. Set the recognizer priority.
//         
CRecog::CRecog()
:CApaDataRecognizerType(KUidEzBoot,KEzRecognizerPriority)
{
        iCountDataTypes
= 1 ;
}

//
///  Returns the size of the data buffer that will be passed to the recognition
///  function (used by the recognition framework)
///  \see DoRecognizeL()
///  \return size of the data buffer
//         
TUint CRecog::PreferredBufSize()
{
   
return (KEzRecognizerBufferSize);
}

//
///  Returns the MIME type that our recognizer is able to manage
///  (used by the recognition framework)
///  \param aIndex: the index of the MIME type to return (will be always 1 for
///                 a recognizer that handles a single MIME type)
///  \return a MIME type
//
TDataType CRecog::SupportedDataTypeL(TInt  /* aIndex */ const
{
   
return (TDataType(KEzbMimeType));
}

/// //
///  The recognition function. The result of the recognition is stored in 
///  the iConfidence data member.
///  \param aName:   the name of the file that contain the data to analyze
///  \param aBuffer: the data buffer
///  \see PreferredBufSize()
/// //
void  CRecog::DoRecognizeL( const  TDesC &  aName,  const  TDesC8 &  aBuffer)
{
   
//  Initialise the result status
   iConfidence  =  ENotRecognized;
   iDataType   
=  TDataType(KEzbMimeType);
   
   
//  Check that we got the required amount of data
    if (aBuffer.Length() < KEzRecognizerBufferSize)
           
return ;

   
//  Check that the file name corresponds to our criteria
   TBool nameOK(EFalse);
   nameOK
= NameRecognized(aName);
   
   
//  Check that the data corresponds to our criteria
   TBool headerOK(EFalse);
   headerOK
= HeaderRecognized(aBuffer);            
   
   
//  Conclude: 
   
//  - if file name and data are OK then the data are certainly recognized
   
//  - if only the data are recognized, then this is only a possibility
   
//  - else the data have not been recognized
    if ( nameOK  &&  headerOK)
   {
           iConfidence
= ECertain;
   }
   
else   if ( ! nameOK  &&  headerOK)
   {
           iConfidence
= EPossible;
   }
   
else
           
return ;
}

/// //
///  The file name recognition function. This functions checks whether the 
///  provided filename matches our criteria (here we want it to have the .boot
///  extension)
///  \param aName: the name to check
///  \return ETrue if the file is OK
/// //
TBool CRecog::NameRecognized( const  TDesC &  aName)

  TBool res
= EFalse;
  
if (aName.Length() > 5 )
  {
     TInt dotPos 
=  aName.LocateReverse(  ' . '  );
     
if  (dotPos  !=  KErrNotFound)
     {
        TInt extLength 
=  aName.Length()  -  dotPos;
        HBufC
*  ext  =  aName.Right( extLength ).AllocL();
        CleanupStack::PushL( ext );
        
if  ( ext -> CompareF(KEzbFileExtension)  ==   0  )
        {
          res 
=  ETrue;
        }
        CleanupStack::PopAndDestroy(); 
//  ext
     }
   }
   
return (res);
}

/// //
///  The data recognition function. This functions checks whether the 
///  provided data starts with our data header
///  extension
///  \param aBuf: the data buffer to check
///  \return ETrue if the data are OK
/// //
TBool CRecog::HeaderRecognized( const  TDesC8 &  aBuf)

   
if (aBuf.Find(KEzbDataHeader) == 0 )
        
return  ETrue;
   
return  EFalse;
}


/// //
///  The Boot code (non leaving). Create a new thread and kicks the real
///  boot code. 
///  \see BootUpKick()
/// //
void  CRecog::BootUp()
{
   
//  Create a new thread
   RThread *  bootThread  =   new  RThread();
   
if (bootThread)
   {
       TInt res
= KErrNone;
       
       
//  and Start it
       res = bootThread -> Create(KBootUpThreadName,
                              CRecog::BootUpKick,
                              KDefaultStackSize,
                              KMinHeapSize,
                              KMinHeapSize,
                              NULL,
                              EOwnerThread);
       
       
if (res == KErrNone)
       {
           bootThread
-> Resume();
           bootThread
-> Close();
       }
       
else
       {
           delete bootThread;
       }
   }
}

/// //
///  The threaded boot code (non leaving). Actually just create a cleanup
///  stack and call a non-leaving implementation of the boot code
///  \see BootUp()
///  \see BootUpKickL()
///  \param aParam: not used but required as a thread entry point
///  \return thread result
/// //
TInt CRecog::BootUpKick(TAny *   /* aParam */ )
{
   TInt err
= KErrNoMemory;
       
//  Create a cleanup stack
   CTrapCleanup  * cleanup = CTrapCleanup::New();
   
if (cleanup)
   {
       
//  and Kick under a trap harness
       TRAP(err,CRecog::BootUpKickL());
       delete cleanup;
   }
   
return  err;
}

/// //
///  The Boot code. 
/// //
void  CRecog::BootUpKickL()
{
        
//  Get the full path (including drive letter)
        
//  to the boot server
        RFs fs;
        User::LeaveIfError(fs.Connect());
        CleanupClosePushL(fs);
        TFindFile findFile(fs);
        User::LeaveIfError(findFile.FindByDir(KEzBootExe,KNullDesC));

        
//  Connect to the Apparc server
        
//  and start our server
        RApaLsSession ls;
        User::LeaveIfError(ls.Connect());
        CleanupClosePushL(ls);
        CApaCommandLine 
* cmd  =  CApaCommandLine::NewLC();
        cmd
-> SetLibraryNameL(findFile.File());
        cmd
-> SetCommandL(EApaCommandOpen);
        User::LeaveIfError(ls.StartApp(
* cmd));

        
//  Delete all stuff on the cleanup stack
        CleanupStack::PopAndDestroy( 3 );
}

MMP文件的源代码:
TARGET      ezrecog.mdl
TARGETTYPE  mdl
TARGETPATH  \system\recogs

UID         
0x10003A19  0x101Fxxxx 

USERINCLUDE   ..\inc
SYSTEMINCLUDE \epoc32\include

SOURCEPATH    ..\src
SOURCE        ezrecog.cpp

LIBRARY       euser.lib 
LIBRARY       apmime.lib apparc.lib apgrfx.lib
LIBRARY       efsrv.lib
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值