示例#1
0
        /// <summary>
        /// Gets the license expiry date timestamp.
        /// </summary>
        /// <returns>Returns the timestamp.</returns>
        public static uint GetLicenseExpiryDate()
        {
            uint expiryDate = 0;
            int  status     = IntPtr.Size == 4 ? LexActivatorNative.GetLicenseExpiryDate_x86(ref expiryDate) : LexActivatorNative.GetLicenseExpiryDate(ref expiryDate);

            switch (status)
            {
            case LexStatusCodes.LA_OK:
                return(expiryDate);

            case LexStatusCodes.LA_FAIL:
                return(0);

            default:
                throw new LexActivatorException(status);
            }
        }
示例#2
0
        /// <summary>
        /// Sets the network proxy to be used when contacting Cryptlex servers.
        ///
        /// The proxy format should be: [protocol://][username:password@]machine[:port]
        ///
        /// NOTE: Proxy settings of the computer are automatically detected. So, in most of the
        /// cases you don't need to care whether your user is behind a proxy server or not.
        /// </summary>
        /// <param name="proxy"></param>
        public static void SetNetworkProxy(string proxy)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetNetworkProxy_x86(proxy) : LexActivatorNative.SetNetworkProxy(proxy);
            }
            else
            {
                status = LexActivatorNative.SetNetworkProxyA(proxy);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#3
0
        /// <summary>
        /// Gets the license meter attribute allowed uses and total uses.
        /// </summary>
        /// <param name="name">name of the meter attribute</param>
        /// <returns>Returns the values of meter attribute allowed and total uses.</returns>
        public static LicenseMeterAttribute GetLicenseMeterAttribute(string name)
        {
            uint allowedUses = 0, totalUses = 0;
            int  status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.GetLicenseMeterAttribute_x86(name, ref allowedUses, ref totalUses) : LexActivatorNative.GetLicenseMeterAttribute(name, ref allowedUses, ref totalUses);
            }
            else
            {
                status = LexActivatorNative.GetLicenseMeterAttributeA(name, ref allowedUses, ref totalUses);
            }
            if (LexStatusCodes.LA_OK == status)
            {
                return(new LicenseMeterAttribute(name, allowedUses, totalUses));
            }
            throw new LexActivatorException(status);
        }
示例#4
0
        /// <summary>
        /// Sets the meter attribute uses for the offline activation request.
        ///
        /// This function should only be called before GenerateOfflineActivationRequest()
        /// function to set the meter attributes in case of offline activation.
        /// </summary>
        /// <param name="name">name of the meter attribute</param>
        /// <param name="uses">the uses value</param>
        public static void SetOfflineActivationRequestMeterAttributeUses(string name, uint uses)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetOfflineActivationRequestMeterAttributeUses_x86(name, uses) : LexActivatorNative.SetOfflineActivationRequestMeterAttributeUses(name, uses);
            }
            else
            {
                status = LexActivatorNative.SetOfflineActivationRequestMeterAttributeUsesA(name, uses);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#5
0
        /// <summary>
        /// Sets the absolute path of the Product.dat file.
        ///
        /// This function must be called on every start of your program
        /// before any other functions are called.
        /// </summary>
        /// <param name="filePath">absolute path of the product file (Product.dat)</param>
        public static void SetProductFile(string filePath)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetProductFile_x86(filePath) : LexActivatorNative.SetProductFile(filePath);
            }
            else
            {
                status = LexActivatorNative.SetProductFileA(filePath);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#6
0
        /// <summary>
        /// Embeds the Product.dat file in the application.
        ///
        /// It can be used instead of SetProductFile() in case you want
        /// to embed the Product.dat file in your application.
        ///
        /// This function must be called on every start of your program
        /// before any other functions are called.
        /// </summary>
        /// <param name="productData">content of the Product.dat file</param>
        public static void SetProductData(string productData)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetProductData_x86(productData) : LexActivatorNative.SetProductData(productData);
            }
            else
            {
                status = LexActivatorNative.SetProductDataA(productData);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#7
0
        /// <summary>
        /// Generates the offline trial activation request needed for generating
        /// offline trial activation response in the dashboard.
        /// </summary>
        /// <param name="filePath">path of the file for the offline request</param>
        public static void GenerateOfflineTrialActivationRequest(string filePath)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.GenerateOfflineTrialActivationRequest_x86(filePath) : LexActivatorNative.GenerateOfflineTrialActivationRequest(filePath);
            }
            else
            {
                status = LexActivatorNative.GenerateOfflineTrialActivationRequestA(filePath);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#8
0
        /// <summary>
        /// Sets the license user email and password for authentication.
        ///
        /// This function must be called before ActivateLicense() or IsLicenseGenuine()
        /// function if 'requireAuthentication' property of the license is set to true.
        /// </summary>
        /// <param name="email">user email address</param>
        /// <param name="password">user password</param>
        public static void SetLicenseUserCredential(string email, string password)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetLicenseUserCredential_x86(email, password) : LexActivatorNative.SetLicenseUserCredential(email, password);
            }
            else
            {
                status = LexActivatorNative.SetLicenseUserCredentialA(email, password);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#9
0
        /// <summary>
        /// Sets server sync callback function.
        ///
        /// Whenever the server sync occurs in a separate thread, and server returns the response,
        /// license callback function gets invoked with the following status codes:
        /// LA_OK, LA_EXPIRED, LA_SUSPENDED, LA_E_REVOKED, LA_E_ACTIVATION_NOT_FOUND,
        /// LA_E_MACHINE_FINGERPRINT, LA_E_AUTHENTICATION_FAILED, LA_E_COUNTRY, LA_E_INET,
        /// LA_E_SERVER, LA_E_RATE_LIMIT, LA_E_IP
        /// </summary>
        /// <param name="callback"></param>
        public static void SetLicenseCallback(CallbackType callback)
        {
            var wrappedCallback = callback;

#if NETFRAMEWORK
            var syncTarget = callback.Target as System.Windows.Forms.Control;
            if (syncTarget != null)
            {
                wrappedCallback = (v) => syncTarget.Invoke(callback, new object[] { v });
            }
#endif
            callbackList.Add(wrappedCallback);

            int status = IntPtr.Size == 4 ? LexActivatorNative.SetLicenseCallback_x86(wrappedCallback) : LexActivatorNative.SetLicenseCallback(wrappedCallback);
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#10
0
        /// <summary>
        /// Extends the local trial.
        ///
        /// NOTE: The function is only meant for local (unverified) trials.
        /// </summary>
        /// <param name="trialExtensionLength">number of days to extend the trial</param>
        /// <returns>LA_OK, LA_FAIL</returns>
        public static int ExtendLocalTrial(uint trialExtensionLength)
        {
            int status = IntPtr.Size == 4 ? LexActivatorNative.ExtendLocalTrial_x86(trialExtensionLength) : LexActivatorNative.ExtendLocalTrial(trialExtensionLength);

            switch (status)
            {
            case LexStatusCodes.LA_OK:
                return(LexStatusCodes.LA_OK);

            case LexStatusCodes.LA_FAIL:
                return(LexStatusCodes.LA_FAIL);

            default:
                throw new LexActivatorException(status);
            }
        }
示例#11
0
        /// <summary>
        /// Resets the meter attribute uses consumed by the activation.
        /// </summary>
        /// <param name="name">name of the meter attribute</param>
        public static void ResetActivationMeterAttributeUses(string name)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.ResetActivationMeterAttributeUses_x86(name) : LexActivatorNative.ResetActivationMeterAttributeUses(name);
            }
            else
            {
                status = LexActivatorNative.ResetActivationMeterAttributeUsesA(name);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#12
0
        /// <summary>
        /// It verifies whether trial has started and is genuine or not. The
        /// verification is done locally.
        ///
        /// This function must be called on every start of your program during the trial period.
        ///
        /// NOTE: The function is only meant for local (unverified) trials.
        /// </summary>
        /// <returns>LA_OK, LA_LOCAL_TRIAL_EXPIRED, LA_FAIL</returns>
        public static int IsLocalTrialGenuine()
        {
            int status = IntPtr.Size == 4 ? LexActivatorNative.IsLocalTrialGenuine_x86() : LexActivatorNative.IsLocalTrialGenuine();

            switch (status)
            {
            case LexStatusCodes.LA_OK:
                return(LexStatusCodes.LA_OK);

            case LexStatusCodes.LA_LOCAL_TRIAL_EXPIRED:
                return(LexStatusCodes.LA_LOCAL_TRIAL_EXPIRED);

            case LexStatusCodes.LA_FAIL:
                return(LexStatusCodes.LA_FAIL);

            default:
                throw new LexActivatorException(status);
            }
        }
示例#13
0
        /// <summary>
        /// Starts the local (unverified) trial.
        ///
        /// This function should be executed when your application starts first time on
        /// the user's computer.
        /// </summary>
        /// <param name="trialLength">trial length in days</param>
        /// <returns>LA_OK, LA_LOCAL_TRIAL_EXPIRED, LA_FAIL</returns>
        public static int ActivateLocalTrial(uint trialLength)
        {
            int status = IntPtr.Size == 4 ? LexActivatorNative.ActivateLocalTrial_x86(trialLength) : LexActivatorNative.ActivateLocalTrial(trialLength);

            switch (status)
            {
            case LexStatusCodes.LA_OK:
                return(LexStatusCodes.LA_OK);

            case LexStatusCodes.LA_LOCAL_TRIAL_EXPIRED:
                return(LexStatusCodes.LA_LOCAL_TRIAL_EXPIRED);

            case LexStatusCodes.LA_FAIL:
                return(LexStatusCodes.LA_FAIL);

            default:
                throw new LexActivatorException(status);
            }
        }
示例#14
0
        /// <summary>
        /// Sets the license key required to activate the license.
        /// </summary>
        /// <param name="licenseKey">a valid license key</param>
        public static void SetLicenseKey(string licenseKey)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetLicenseKey_x86(licenseKey) : LexActivatorNative.SetLicenseKey(licenseKey);
            }
            else
            {
                status = LexActivatorNative.SetLicenseKeyA(licenseKey);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#15
0
        /// <summary>
        /// Gets the company associated with the license user.
        /// </summary>
        /// <returns>Returns the license user company.</returns>
        public static string GetLicenseUserCompany()
        {
            var builder = new StringBuilder(256);
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.GetLicenseUserCompany_x86(builder, builder.Capacity) : LexActivatorNative.GetLicenseUserCompany(builder, builder.Capacity);
            }
            else
            {
                status = LexActivatorNative.GetLicenseUserCompanyA(builder, builder.Capacity);
            }
            if (LexStatusCodes.LA_OK == status)
            {
                return(builder.ToString());
            }
            throw new LexActivatorException(status);
        }
示例#16
0
        /// <summary>
        /// Sets the trial activation metadata.
        ///
        /// The  metadata appears along with the trial activation details of the product
        /// in dashboard.
        /// </summary>
        /// <param name="key">string of maximum length 256 characters with utf-8 encoding</param>
        /// <param name="value">string of maximum length 256 characters with utf-8 encoding</param>
        public static void SetTrialActivationMetadata(string key, string value)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetTrialActivationMetadata_x86(key, value) : LexActivatorNative.SetTrialActivationMetadata(key, value);
            }
            else
            {
                status = LexActivatorNative.SetTrialActivationMetadataA(key, value);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#17
0
        /// <summary>
        /// Gets the activation metadata.
        /// </summary>
        /// <param name="key">key to retrieve the value</param>
        /// <returns>Returns the value of metadata for the key.</returns>
        public static string GetActivationMetadata(string key)
        {
            var builder = new StringBuilder(256);
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.GetActivationMetadata_x86(key, builder, builder.Capacity) : LexActivatorNative.GetActivationMetadata(key, builder, builder.Capacity);
            }
            else
            {
                status = LexActivatorNative.GetActivationMetadataA(key, builder, builder.Capacity);
            }
            if (LexStatusCodes.LA_OK == status)
            {
                return(builder.ToString());
            }
            throw new LexActivatorException(status);
        }
示例#18
0
        /// <summary>
        /// Sets the current app version of your application.
        ///
        /// The app version appears along with the activation details in dashboard. It
        /// is also used to generate app analytics.
        /// </summary>
        /// <param name="appVersion"></param>
        public static void SetAppVersion(string appVersion)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.SetAppVersion_x86(appVersion) : LexActivatorNative.SetAppVersion(appVersion);
            }
            else
            {
                status = LexActivatorNative.SetAppVersionA(appVersion);
            }
            if (LexStatusCodes.LA_OK != status)
            {
                throw new LexActivatorException(status);
            }
        }
示例#19
0
        /// <summary>
        /// Gets the meter attribute uses consumed by the activation.
        /// </summary>
        /// <param name="name"></param>
        /// <returns>Returns the value of meter attribute uses by the activation.</returns>
        public static uint GetActivationMeterAttributeUses(string name)
        {
            uint uses = 0;
            int  status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.GetActivationMeterAttributeUses_x86(name, ref uses) : LexActivatorNative.GetActivationMeterAttributeUses(name, ref uses);
            }
            else
            {
                status = LexActivatorNative.GetActivationMeterAttributeUsesA(name, ref uses);
            }
            if (LexStatusCodes.LA_OK == status)
            {
                return(uses);
            }
            throw new LexActivatorException(status);
        }
示例#20
0
        /// <summary>
        /// Activates your trial using the offline activation response file.
        /// </summary>
        /// <param name="filePath">path of the offline activation response file.</param>
        /// <returns>LA_OK, LA_TRIAL_EXPIRED, LA_FAIL</returns>
        public static int ActivateTrialOffline(string filePath)
        {
            int status;

            if (LexActivatorNative.IsWindows())
            {
                status = IntPtr.Size == 4 ? LexActivatorNative.ActivateTrialOffline_x86(filePath) : LexActivatorNative.ActivateTrialOffline(filePath);
            }
            else
            {
                status = LexActivatorNative.ActivateTrialOfflineA(filePath);
            }
            switch (status)
            {
            case LexStatusCodes.LA_OK:
                return(LexStatusCodes.LA_OK);

            case LexStatusCodes.LA_TRIAL_EXPIRED:
                return(LexStatusCodes.LA_TRIAL_EXPIRED);

            case LexStatusCodes.LA_FAIL:
                return(LexStatusCodes.LA_FAIL);

            default:
                throw new LexActivatorException(status);
            }
        }