Analysis on How to dynamically load DLL in C ++ on Windows Mobile

We will explain the implementation of Native C ++ dynamic DLL loading in Windows Mobile. Static Loading is generally very simple and will be mentioned in this article. This article mainly explains how to dynamically load DLL in C ++.

Introduction

This document uses the Windows Mobile Sensors API library as an example to describe how to use Native C ++ to dynamically load DLL in Windows Mobile.

Static DLL Loading Method

Native C ++ development is generally used to load the DLL using the static loading method. The so-called static loading is to directly call the function defined by the DLL header file during program compilation (Compile Time, link Time Link *. the lib file points to the DLL interface and loads the DLL when the program starts running.

The following describes how to use static DLL loading. in the program, you must specify the loaded *. lib file for Link ).

# Pragma comment (lib, "SamsungMobileSDK_1.lib ")

Static DLL can be used to directly call the function defined by the header file, for example:

 
 

  
  
SmiAccelerometerCapabilities cap;
  
  
if( SmiAccelerometerGetCapabilities(&cap) != SMI_SUCCESS){    throw;}
  
  
SmiAccelerometerHandler h = &GetVectorHandler;if(SmiAccelerometerRegisterHandler(1000, h) != SMI_SUCCESS)
  
  
{    throw;} 
 
 

SmiAccelerometerGetCapabilities () and SmiAccelerometerRegisterHandler () are defined in the header file smiAccelerometer. h and can be called directly. The definition is as follows:

Static Loading is easy to use. However, during dynamic loading, you cannot directly call the function of the header file. This increases the complexity.

 
 

  
  
/**  
  
  
*  Start receiving accelerometer data periodically.   
  
  
*   
  
  
*  The period interval must be a multiple of the callbackPeriod specified   
  
  
*  in SmiAccelerometerCapabilities. If it is less than the callbackPeriod, it will be   
  
  
*  set to the callbackPeriod. If it is not a multiple of the callbackPeriod, it will be   
  
  
*  truncated to fit the value. ( (period / callbackPeriod)   
  
  
* callbackPeriod )   
  
  
*     
  
  
*  Only one handler per process is allowed. Successive calls per process will replace the previous handler   
  
  
*  function and period.   
  
  
*  
  
  
*  @param    period    [in]    callback interval.      
  
  
*  @param    handler   [in]    callback function for every period interval.     
  
  
*   
  
  
*  @return                      
  
  
*                              SMI_SUCCESS on success   
  
  
*  \n                          SMI_ERROR_INVALID_PARAMETER if the handler input parameter is NULL   
  
  
*  \n                          SMI_ERROR_DEVICE_NOT_FOUND if the device is not present or supported   
  
  
*  \n                          SMI_ERROR_CANNOT_ACTIVATE_SERVER if the sensor server cannot be started   
  
  
*/ SMI_API SMI_RESULT SmiAccelerometerRegisterHandler(UINT period, SmiAccelerometerHandler handler); 
 
 

C ++ dynamic DLL Loading Method

Static DLL loading is a relatively simple development method, but there is a drawback that when the program starts running, it needs to load the DLL. If the DLL does not exist, the program cannot start. Because the Windows Mobile Sensors API library needs to adapt to specific devices, that is to say, the Windows Mobile Sensors API library cannot depend on the Sensor library of specific devices, so you cannot use static loading methods to reference DLL. The following describes how to dynamically load a DLL.

Define pointer to function

To dynamically load a DLL, define the pointer to the function according to the header file, as shown below:

 
 

  
  
typedef UINT (WINAPI * PFN_SmiAccelerometerGetVector)(SmiAccelerometerVector*);  
  
  
typedef UINT (WINAPI * PFN_SmiAccelerometerGetCapabilities)(SmiAccelerometerCapabilities*);  
  
  
typedef UINT (WINAPI * PFN_SmiAccelerometerRegisterHandler)(UINT, SmiAccelerometerHandler);typedef UINT (WINAPI * PFN_SmiAccelerometerUnregisterHandler)();  
  
  
PFN_SmiAccelerometerGetVector pfnSmiAccelerometerGetVector;PFN_SmiAccelerometerGetCapabilities   
  
  
pfnSmiAccelerometerGetCapabilities;PFN_SmiAccelerometerRegisterHandler   
  
  
pfnSmiAccelerometerRegisterHandler;PFN_SmiAccelerometerUnregisterHandler pfnSmiAccelerometerUnregisterHandler; 
 
 

These pointers to functions can be defined according to the following functions in the smiAccelerometer. h header file:

 
 

  
  
SMI_API SMI_RESULT SmiAccelerometerGetVector(SmiAccelerometerVector *accel);  
  
  
SMI_API SMI_RESULT SmiAccelerometerGetCapabilities(SmiAccelerometerCapabilities *capabilities);  
  
  
SMI_API SMI_RESULT SmiAccelerometerRegisterHandler(UINT period, SmiAccelerometerHandler handler);  
  
  
SMI_API SMI_RESULT SmiAccelerometerUnregisterHandler(); 
 
 

The definitions are one-to-one. The parameter entries and return values must be exactly the same.

Initialize pointer to function

The initialization process of the pointer to the function is the process of dynamically loading the DLL. The Code is as follows:

 
 

  
  
#define SAMSUNG_SENSOR_DLL  
  
  
L"SamsungMobilesdk_1.dll"HMODULE hSensorLib = LoadLibrary (SAMSUNG_SENSOR_DLL);if (NULL == hSensorLib){      
  
  
printf("Unable to load Samsung Sensor DLL\n");      
  
  
throw std::runtime_error("Unable to load Samsung Sensor DLL");}  
  
  
pfnSmiAccelerometerGetVector = (PFN_SmiAccelerometerGetVector)      
  
  
GetProcAddress(hSensorLib, L"SmiAccelerometerGetVector");pfnSmiAccelerometerGetCapabilities = (PFN_SmiAccelerometerGetCapabilities)      
  
  
GetProcAddress(hSensorLib, L"SmiAccelerometerGetCapabilities");pfnSmiAccelerometerRegisterHandler = (PFN_SmiAccelerometerRegisterHandler)      
  
  
GetProcAddress(hSensorLib, L"SmiAccelerometerRegisterHandler");pfnSmiAccelerometerUnregisterHandler = (PFN_SmiAccelerometerUnregisterHandler)     
  
  
GetProcAddress(hSensorLib, L"SmiAccelerometerUnregisterHandler");if (NULL == pfnSmiAccelerometerGetVector){    printf("Unable to find entry point of SmiAccelerometerGetVector\n");      
  
  
throw std::runtime_error("Unable to find entry point of SmiAccelerometerGetVector");}if (NULL == pfnSmiAccelerometerGetCapabilities){      
  
  
printf("Unable to find entry point of SmiAccelerometerGetCapabilities\n");      
  
  
throw std::runtime_error("Unable to find entry point of SmiAccelerometerGetCapabilities");}if (NULL == pfnSmiAccelerometerRegisterHandler){      
  
  
printf("Unable to find entry point of SmiAccelerometerRegisterHandler\n");      
  
  
throw std::runtime_error("Unable to find entry point of SmiAccelerometerRegisterHandler");}if (NULL == pfnSmiAccelerometerUnregisterHandler){      
  
  
printf("Unable to find entry point of SmiAccelerometerUnregisterHandler\n");      
  
  
throw std::runtime_error("Unable to find entry point of SmiAccelerometerUnregisterHandler");} 
 
 

The LoadLibrary () function dynamically loads DLL. GetProcAddress () loads the function entry address based on the function name to the pointer to the function. A little detour, sorry. If the address is not blank, you can call the corresponding function based on the address.

Call a function

The method for calling a function is the same as that for loading a DLL statically, but instead of calling the function name directly, it is called using a pointer to the function, the following example can be compared with the static loading DLL function call example.

 
 

  
  
SmiAccelerometerCapabilities cap;   
  
  
if( pfnSmiAccelerometerGetCapabilities(&cap) != SMI_SUCCESS)  
  
  
 {      
  
  
throw;}SmiAccelerometerHandler h = &GetVectorHandler;  
  
  
if(pfnSmiAccelerometerRegisterHandler(1000, h) != SMI_SUCCESS)  
  
  
{    throw;} 
 
 

C ++ completes the dynamic DLL loading method.

. NET World

The following paragraph is incorrect. Please refer to the following reply .. NET using the DllImport attribute for P/Invoke should not be called dynamic loading, because it cannot be uninstalled, it should be called on-demand loading, that is, loading only when calling this function, instead of loading it when the program starts. The difference between on-demand loading and static loading is that the loading time is different.

{

In. NET, P/Invoke. All functions in a DLL are dynamically loaded. This is wrong. Thanks to Wuya, it should be called On-Demand Loading. For the dynamic loading method, see Wuya to reply) is defined using the DllImport attribute. If the SmiAccelerometerUnregisterHandler () function is used in. NET, it is defined as follows:

[DllImport ("SamsungMobileSDK_1.dll", CharSet = CharSet. Auto, SetLastError = true)] private static extern uint evaluate (); Using. NET is easier than using Native C ++ for dynamic loading.

}

Mobile Sensors API Project

This project is still in its infancy. Currently, samsung's gravity sensor is implemented. I host the project to Mobile Sensors API-Native uniied APIs for Windows Mobile Sensors, and I will continue to improve it, implement various sensors in this project.

Source code: http://mobilesensor.codeplex.com/SourceControl/ListDownloadableCommits.aspx

Environment: VS2008 + WM 6 professional SDK + Samsung Windows Mobile SDK

Original article title: Native C ++ dynamic DLL loading in Windows Mobile

Link: http://www.cnblogs.com/procoder/archive/2009/09/25/1573712.html