Cette fonction permet d’obtenir un pointeur vers l’interface IEngine. Elle prend comme paramètre d’entrée le numéro Customer Project ID, qui est une string alphanumérique commune à toutes les licences Developer et Runtime utilisées dans votre projet.
Pour les utilisateurs de Linux et de Windows, cette fonction facilite l’accès à la licence en ligne si nécessaire et permet également de spécifier certains paramètres supplémentaires lors de l’initialisation.
Private Declare Function InitializeEngine Lib "FREngine.dll" ( _ CustomerProjectID As String, _ LicensePath As String, _ LicensePassword As String, _ FREngineDataFolder As String, _ FREngineTempFolder As String, _ IsSharedCPUCoresMode As Boolean, _ ByRef Engine As FREngine.IEngine) _As Integer
CustomerProjectID[in] Une string contenant le Customer Project ID.
Lors de l’initialisation de la bibliothèque, la liste de toutes les licences disponibles est parcourue afin de rechercher une licence Developer ou Runtime correspondant à ce Customer Project ID. Si aucune licence correspondante n’est trouvée, une erreur se produit pour la dernière licence vérifiée. Vous pouvez toutefois passer 0 pour ce paramètre et sélectionner la licence ultérieurement, en appelant la méthode IEngine::SetCurrentLicense avant toute autre méthode de la bibliothèque.
LicensePath[in] Le nom complet du fichier de la licence en ligne. Si vous n’utilisez pas de licence en ligne, passez à la place une chaîne vide "" ou un pointeur Null. La chaîne vide "" ou le pointeur Null doivent être passés.Pour les utilisateurs de macOS : ce paramètre est réservé à une utilisation future.LicensePassword[in] Le mot de passe de la licence en ligne. Si vous n’utilisez pas de licence en ligne, passez à la place une chaîne vide "" ou un pointeur Null.Pour les utilisateurs de macOS : ce paramètre est réservé à une utilisation future.FREngineDataFolder[in] Contient le chemin du dossier dans lequel ABBYY FineReader Engine doit stocker les données spécifiques à l’utilisateur.Par défaut, pour l’installation automatique :%ProgramData%\ABBYY\SDK\12\FineReader Engine for auxiliary engine dataEn outre, pour Linux et Windows :%ProgramData%\ABBYY\SDK\12\Licenses for license dataSi vous définissez la valeur de FREngineDataFolder, toutes les informations auxiliaires seront écrites dans un nouveau dossier de données.Vous devrez peut-être modifier la valeur par défaut, par exemple si les paramètres de langue de l’interface de votre application doivent être différents de ceux des autres applications utilisant FineReader Engine. Après avoir modifié cette valeur par défaut, assurez-vous de disposer des autorisations de contrôle total sur le nouveau dossier de données.FREngineTempFolder[in] Contient le chemin du dossier des fichiers temporaires d’ABBYY FineReader Engine. Par défaut, il s’agit du dossier %TEMP%\ABBYY FineReader Engine 12.IsSharedCPUCoresMode[in] Indique si les cœurs du CPU doivent être utilisés en mode partagé. Il existe deux modes d’utilisation des cœurs du CPU : séparé et partagé. En mode séparé, ABBYY FineReader Engine n’utilise pas plus de processus que ce qui est autorisé par la licence. En mode partagé, un nombre quelconque de processus peut être exécuté, mais tous ces processus n’utiliseront que les cœurs du CPU spécifiés par la propriété IMultiProcessingParams::SharedCPUCoresMask.
Ce paramètre est ignoré dans ABBYY FineReader Engine pour Windows.
Engine[out, retval] Un pointeur vers une variable pointeur IEngine* qui reçoit le pointeur d’interface vers l’objet Engine obtenu.
Un seul objet Engine peut être créé à l’aide de cette fonction dans une même instance de l’application utilisant ABBYY FineReader Engine. Toute tentative répétée de création de l’objet Engine renverra le même objet.
La création de l’objet Engine peut prendre un certain temps. Lors de l’initialisation, le moteur charge la bibliothèque principale indiquée ci-dessous ainsi qu’un grand nombre d’autres bibliothèques dynamiques :
Linux: libFREngine.so
macOS: libFREngine.dylib
Windows: FREngine.dll
Lors de l’utilisation d’une licence réseau, l’initialisation sous Linux et Windows peut également être plus longue en raison de la communication avec le serveur de licences. Assurez-vous que la connexion réseau offre les performances requises ; une bande passante d’au moins 100 Kb/s est recommandée pour garantir un fonctionnement fiable avec une licence réseau.
Il est possible de créer et d’exécuter l’objet Engine sur un système multiprocesseur, mais il ne peut y avoir qu’un seul objet Engine par processus. Un deuxième appel à InitializeEngine dans le même processus renverra une référence vers l’objet existant. Vous devez donc créer un objet Engine distinct pour chaque processus en appelant la fonction InitializeEngine.
Pour les implémentations d’ABBYY FineReader Engine for Windows sur des systèmes multiprocesseurs, d’autres méthodes de chargement de l’objet Engine peuvent s’avérer utiles.
N’initialisez ni ne désinitialisez ABBYY FineReader Engine aux points d’entrée d’autres bibliothèques dynamiques, ni dans les constructeurs et destructeurs d’objets statiques et globaux implémentés dans des bibliothèques dynamiques, car ils sont appelés aux points d’entrée de ces bibliothèques dynamiques.
L’utilisateur doit initialiser et désinitialiser ABBYY FineReader Engine ailleurs. Par exemple, dans la fonction main ou WinMain d’un module exécutable.
: Sous Windows, cette restriction est due au fait que les fonctions Win32 LoadLibrary et FreeLibrary ne sont pas réentrantes.
Lors de l’initialisation, ABBYY FineReader Engine rétablit le paramètre LC_CTYPE à sa valeur par défaut du système d’exploitation. Il faut en tenir compte si votre application dépend de services liés aux paramètres régionaux (notamment msvcrt.dll sous Windows).Les développeurs Windows utilisant .NET doivent veiller à spécifier [STAThread] (modèle d’appartement monothread) comme attribut de la fonction principale de l’application ; sinon, une erreur peut se produire :
[STAThread]public static void Main(){ ...}
Vous devez transmettre un numéro Customer Project ID valide comme paramètre d’entrée. Toutefois, vous pouvez choisir la licence à utiliser pour le traitement en appelant la méthode SetCurrentLicense de l’objet Engine avant toute méthode de traitement. Utilisez la méthode GetAvailableLicenses pour parcourir la liste des licences activées disponibles, ainsi que la propriété CurrentLicense de l’objet Engine pour vérifier quelle licence est actuellement sélectionnée.
// Initialisez ces variables avec le chemin d’accès à FREngine.dll, votre Customer Project ID pour FineReader Engine,// et, le cas échéant, le chemin d’accès au jeton de licence en ligne et le mot de passe de la licence en lignewchar_t* FreDllPath;wchar_t* CustomerProjectId;wchar_t* LicensePath; // si vous n’utilisez pas de licence en ligne, affectez des chaînes vides à ces variableswchar_t* LicensePassword;// HANDLE de FREngine.dllstatic HMODULE libraryHandle = 0;// Objet FineReader Engine global.FREngine::IEnginePtr Engine;void LoadFREngine(){ if( Engine != 0 ) { // Déjà chargé return; } // Première étape : charger FREngine.dll if( libraryHandle == 0 ) { libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH ); if( libraryHandle == 0 ) { throw L"Erreur lors du chargement d'ABBYY FineReader Engine"; } } // Deuxième étape : obtenir l’objet Engine typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, BSTR, VARIANT_BOOL, FREngine::IEngine** ); InitializeEngineFunc pInitializeEngine = ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" ); if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) { UnloadFREngine(); throw L"Erreur lors du chargement d'ABBYY FineReader Engine"; }}
Code C#
public class EngineLoader : IDisposable{ public EngineLoader() { // Initialisez ces variables avec le chemin complet vers FREngine.dll, votre Customer Project ID // et, le cas échéant, le chemin vers votre fichier de jeton de licence en ligne ainsi que le mot de passe de la licence en ligne string enginePath = ""; string customerProjectId = ""; string licensePath = ""; string licensePassword = ""; // Charger la bibliothèque FREngine.dll dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH); try { if (dllHandle == IntPtr.Zero) { throw new Exception("Can't load " + enginePath); } IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine"); if (initializeEnginePtr == IntPtr.Zero) { throw new Exception("Can't find InitializeEngine function"); } IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine"); if (deinitializeEnginePtr == IntPtr.Zero) { throw new Exception("Can't find DeinitializeEngine function"); } IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow"); if (dllCanUnloadNowPtr == IntPtr.Zero) { throw new Exception("Can't find DllCanUnloadNow function"); } // Convertir les pointeurs en délégués initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer( initializeEnginePtr, typeof(InitializeEngine)); deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer( deinitializeEnginePtr, typeof(DeinitializeEngine)); dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer( dllCanUnloadNowPtr, typeof(DllCanUnloadNow)); // Appeler la fonction InitializeEngine // en lui transmettant le chemin du fichier de licence en ligne et le mot de passe de la licence en ligne int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, "", "", false, ref engine); Marshal.ThrowExceptionForHR(hresult); } catch (Exception) { // Libérer la bibliothèque FREngine.dll engine = null; // Suppression de tous les objets avant l'appel à FreeLibrary GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); FreeLibrary(dllHandle); dllHandle = IntPtr.Zero; initializeEngine = null; deinitializeEngine = null; dllCanUnloadNow = null; throw; } } // Fonctions de Kernel32.dll [DllImport("kernel32.dll")] private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags); private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008; [DllImport("kernel32.dll")] private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName); [DllImport("kernel32.dll")] private static extern bool FreeLibrary(IntPtr hModule); // Fonctions de FREngine.dll [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)] private delegate int InitializeEngine(string customerProjectId, string licensePath, string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, ref FREngine.IEngine engine); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int DeinitializeEngine(); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int DllCanUnloadNow(); // Variables privées private FREngine.IEngine engine = null; // Handle de FREngine.dll private IntPtr dllHandle = IntPtr.Zero; private InitializeEngine initializeEngine = null; private DeinitializeEngine deinitializeEngine = null; private DllCanUnloadNow dllCanUnloadNow = null;}
