Saltar al contenido principal
Esta función se utiliza para obtener un puntero a la interfaz IEngine. Toma como parámetro de entrada el número Customer Project ID, que es una cadena alfanumérica común a todas las licencias Developer y Runtime que utiliza su proyecto.
Para los usuarios de Linux y Windows, esta función facilita el acceso al licenciamiento en línea, si es necesario, y también permite especificar algunos parámetros adicionales durante la inicialización.

​
Sintaxis

​
C++

HRESULT __stdcall InitializeEngine(
  BSTR CustomerProjectID,
  BSTR LicensePath,
  BSTR LicensePassword,
  BSTR FREngineDataFolder,
  BSTR FREngineTempFolder,
  VARIANT_BOOL IsSharedCPUCoresMode,
  IEngine** Engine
);

​
C#

int InitializeEngine(
  string CustomerProjectID,
  string LicensePath,
  string LicensePassword,
  string FREngineDataFolder,
  string FREngineTempFolder,
  bool IsSharedCPUCoresMode,
  ref IEngine Engine
);

​
Visual Basic .NET

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

​
Parámetros

CustomerProjectID [in] Una cadena que contiene el Customer Project ID.
Durante la inicialización de la biblioteca, se busca en la lista de todas las licencias disponibles una licencia de Developer o Runtime que corresponda a este Customer Project ID. Si no se encuentra ninguna licencia correspondiente, se producirá un error para la última licencia comprobada. No obstante, puede pasar 0 para este parámetro y seleccionar la licencia más adelante, llamando al método IEngine::SetCurrentLicense antes de cualquier otro método de la biblioteca.
LicensePath [in] El nombre completo del archivo de la licencia en línea. Si no usa una licencia en línea, pase una cadena vacía "" o un puntero Null. Debe pasarse una cadena vacía "" o un puntero Null. Para los usuarios de macOS: Este parámetro está reservado para uso futuro. LicensePassword [in] La contraseña de la licencia en línea. Si no usa una licencia en línea, pase una cadena vacía "" o un puntero Null. Para los usuarios de macOS: Este parámetro está reservado para uso futuro. FREngineDataFolder [in] Contiene la ruta a la carpeta en la que ABBYY FineReader Engine debe almacenar los datos específicos del usuario. De forma predeterminada, para la instalación automática: %ProgramData%\ABBYY\SDK\12\FineReader Engine for auxiliary engine data Además, para Linux y Windows: %ProgramData%\ABBYY\SDK\12\Licenses for license data Si establece el valor de FREngineDataFolder, toda la información auxiliar se escribirá en una nueva carpeta de datos. Puede que necesite cambiar el valor predeterminado, por ejemplo, si la configuración del idioma de la interfaz de su aplicación debe ser distinta de la de otras aplicaciones que usan FineReader Engine. Después de cambiar el valor predeterminado, asegúrese de tener permisos de control total sobre la nueva carpeta de datos. FREngineTempFolder [in] Contiene la ruta a la carpeta para los archivos temporales de ABBYY FineReader Engine. De forma predeterminada, es la carpeta %TEMP%\ABBYY FineReader Engine 12. IsSharedCPUCoresMode [in] Especifica si los núcleos de CPU deben usarse en modo compartido. Hay dos modos de uso de los núcleos de CPU: separado y compartido. En el modo separado, ABBYY FineReader Engine no usa más procesos de los permitidos por la licencia. En el modo compartido, puede ejecutarse cualquier número de procesos, pero todos estos procesos usarán solo los núcleos de CPU especificados por la propiedad IMultiProcessingParams::SharedCPUCoresMask.
Este parámetro se omite en ABBYY FineReader Engine for Windows.
Engine [out, retval] Un puntero a una variable de puntero IEngine* que recibe el puntero de interfaz al objeto Engine resultante.

​
Valores de retorno

La función puede devolver los valores de retorno estándar de las funciones de ABBYY FineReader Engine.

​
Observaciones

Solo se puede crear un objeto Engine con esta función en una única instancia de la aplicación que usa ABBYY FineReader Engine. Los intentos posteriores de crear el objeto Engine devolverán el mismo objeto.
La creación del objeto Engine puede llevar un tiempo considerable. Durante la inicialización, el motor carga la biblioteca principal que se indica a continuación, junto con un gran número de bibliotecas dinámicas adicionales:
  • Linux: libFREngine.so
  • macOS: libFREngine.dylib
  • Windows: FREngine.dll
Cuando se usa una licencia de red, la inicialización en Linux y Windows también puede tardar más debido a la comunicación con el servidor de licencias. Asegúrese de que la conexión de red cumpla los requisitos de rendimiento; se recomienda un ancho de banda de al menos 100 Kb/s para un funcionamiento fiable con una licencia de red.
Es posible crear y ejecutar el objeto Engine en un sistema multiprocesador, pero solo puede haber un objeto Engine por proceso. Una segunda llamada a InitializeEngine dentro del mismo proceso devolverá una referencia al objeto existente. Por lo tanto, debe crear un objeto Engine independiente para cada proceso llamando a la función InitializeEngine.
En implementaciones de ABBYY FineReader Engine for Windows que impliquen sistemas multiprocesador, puede resultarle útil consultar otros métodos para cargar el objeto Engine.
No inicialice ni desinicialice ABBYY FineReader Engine en los puntos de entrada de otras bibliotecas dinámicas ni en los constructores y destructores de objetos estáticos y globales implementados en bibliotecas dinámicas, ya que estos se ejecutan en los puntos de entrada de la biblioteca dinámica.
El usuario debe inicializar y desinicializar ABBYY FineReader Engine en otro lugar. Por ejemplo, en la función main o WinMain de un módulo ejecutable.
: En Windows, esta restricción se debe a que las funciones Win32 LoadLibrary y FreeLibrary no son reentrantes.
Durante la inicialización, ABBYY FineReader Engine restablecerá la configuración de LC_CTYPE a los valores predeterminados del sistema operativo. Esto debe tenerse en cuenta si la aplicación depende de servicios dependientes de la configuración regional (en concreto, msvcrt.dll en Windows). Los desarrolladores de Windows que usan .NET deben asegurarse de especificar [STAThread] (modelo de apartamento de un solo hilo) como atributo en la función principal de la aplicación; de lo contrario, puede producirse un error: 
[STAThread]
public static void Main()
{
  ...
}
Debe proporcionar un número de Customer Project ID válido como parámetro de entrada. No obstante, puede elegir la licencia que se utilizará para el procesamiento llamando al método SetCurrentLicense del objeto Engine antes de cualquiera de los métodos de procesamiento. Use el método GetAvailableLicenses para consultar la lista de licencias activadas disponibles que puede usar, y la propiedad CurrentLicense del objeto Engine para comprobar qué licencia está seleccionada actualmente para su uso.

​
Ejemplos

// Inicialice estas variables con la ruta de acceso a FREngine.dll, el Customer Project ID de FineReader Engine
// y, si corresponde, la ruta al token de la licencia en línea y la contraseña de la licencia en línea
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // si no usa una licencia en línea, asigne cadenas vacías a estas variables
wchar_t* LicensePassword;
// HANDLE de FREngine.dll
static HMODULE libraryHandle = 0;
// Objeto global de FineReader Engine.
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Ya se cargó
    return;
    }
    // Primer paso: cargar FREngine.dll
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Error al cargar ABBYY FineReader Engine";
        }
    }
    // Segundo paso: obtener el objeto 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"Error al cargar ABBYY FineReader Engine";
    }
}

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Inicialice estas variables con la ruta completa a FREngine.dll, su Customer Project ID
        // y, si corresponde, la ruta al archivo de token de la licencia en línea y la contraseña de la licencia en línea
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Cargue la biblioteca 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");
            }
            // Convierta los punteros en delegados
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Llame a la función InitializeEngine 
            // y pase la ruta al archivo de licencia en línea y la contraseña de la licencia en línea
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Libere la biblioteca FREngine.dll
            engine = null;
            // Elimine todos los objetos antes de llamar a FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Funciones 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);
    // Funciones 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 privadas
    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;
}
La función se usa en todos los ejemplos de código, excepto en EnginesPool (Win).

​
Consulte también

Gestión de licencias Módulos DeinitializeEngine Diferentes formas de cargar el objeto Engine (Win)