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

hagensas

浏览: 12380 次

最近访客更多访客>>

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (7)

社区版块

存档分类

Symbian EXT Nokia thread OS

根据以往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.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

分享到：