How to Initialize Anyline Mobile SDK

The SDK initialization is a required step in order to use Anyline Mobile SDK. It performs important operations to ensure the scanning process can happen, such as:

Authenticates your license key;
Validates and copies necessary files to the device;
Initializes other objects in the environment.

The previous AnylineSdk.init(String, Context) call has been deprecated in version 54.6.0. Please use one of the following methods to ensure correct SDK initialization.

Initialization Strategies

Option 1: Initialize in background

This initialization strategy is the recommended way for most cases, as it allows the SDK to decide the best time to perform the necessary tasks by monitoring network conditions and scanner utilization.

Kotlin
Java

class MainApplication: Application() {
    override fun onCreate() {
        super.onCreate()

        AnylineSdk.init(this, SdkInitializationConfig(
            sdkInitializationParameters = SdkInitializationParameters("myLicenseKey"),
            sdkInitializationStrategy = SdkInitializationStrategy.AsyncAuto(object: SdkInitializationListener {
                override fun onInitializationStarted() {
                    Log.d("AnylineSdkInit", "Anyline SDK initialization in progress...")
                }

                override fun onInitializationFailed(state: SdkInitializationState.NotInitialized) {
                    Log.e("AnylineSdkInit", "Anyline SDK not initialized: ${state.lastError?.exception?.message}")
                }

                override fun onInitializationSucceeded(state: SdkInitializationState.Initialized) {
                    Log.d("AnylineSdkInit", "Anyline SDK initialized!")
                }
            }))
        )
    }
}

public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        try {
            AnylineSdk.init(this, new SdkInitializationConfig(
                    new SdkInitializationParameters("myLicenseKey"),
                    new SdkInitializationStrategy.AsyncAuto(new SdkInitializationListener() {
                        @Override
                        public void onInitializationStarted() {
                            Log.d("AnylineSdkInit", "Anyline SDK initialization in progress...");
                        }

                        @Override
                        public void onInitializationFailed(@NonNull SdkInitializationState.NotInitialized notInitialized) {
                            String errorMessage = "";
                            SdkInitializationError lastError = notInitialized.getLastError();
                            if (lastError != null) {
                                errorMessage = lastError.getException().getMessage();
                            }
                            Log.e("AnylineSdkInit", "Anyline SDK not initialized: " + errorMessage + ".");
                        }

                        @Override
                        public void onInitializationSucceeded(@NonNull SdkInitializationState.Initialized initialized) {
                            Log.d("AnylineSdkInit", "Anyline SDK initialized!");
                        }
                    }, null)));
        } catch (Exception e) {
            Log.e("AnylineSdkInit", "Anyline SDK not initialized: " + e.getMessage() + ".");
        }
    }
}

Option 2: Initialize using blocking call

Replaces the previous AnylineSdk.init(String, Context) call. This method is only recommended if you use an offline license and want to have autonomy over when exactly the SDK is initialized.

Kotlin
Java

try {
    AnylineSdk.init(context, SdkInitializationConfig(
        sdkInitializationParameters = SdkInitializationParameters("myLicenseKey"),
        sdkInitializationStrategy = SdkInitializationStrategy.SyncManual))
    Log.d("AnylineSdkInit", "Anyline SDK initialized!")
} catch (e: Exception) {
    Log.e("AnylineSdkInit", "Anyline SDK not initialized: ${e.message.toString()}.")
}

try {
    AnylineSdk.init(context, new SdkInitializationConfig(
        new SdkInitializationParameters("myLicenseKey"),
        SdkInitializationStrategy.SyncManual.INSTANCE));
    Log.d("AnylineSdkInit", "Anyline SDK initialized!");
} catch (Exception e) {
    Log.e("AnylineSdkInit", "Anyline SDK not initialized: " + e.getMessage().toString() + ".");
}

Option 3: Initialize using the ContentProvider

This is the easiest way to initialize the SDK. All you need to do is let your application implement AnylineSdkInitializationContentProviderInterface and provide the SDK initialization parameters by calling AnylineSdkInitializationContentProviderHandler.proceedWithSdkInitializationParameters(SdkInitializationParameters) . The same criteria as for the background strategy will be used to define the best time to initialize the SDK.

Kotlin
Java

class MainApplication: Application(), AnylineSdkInitializationContentProviderInterface {
    override fun onAnylineSdkInitializationContentProviderHandlerAvailable(
        initializationHandler: AnylineSdkInitializationContentProviderHandler) {

        val mySdkInitializationParameters = SdkInitializationParameters(
            licenseKey = "myLicenseKey"
        )
        initializationHandler.proceedWithSdkInitializationParameters(mySdkInitializationParameters)
    }


    override fun onAnylineSdkInitializationContentProviderMessage(message: String) {
        Log.d("AnylineSdkInitProvider", message)
    }
}

public class MainApplication extends Application implements AnylineSdkInitializationContentProviderInterface {
    @Override
    public void onAnylineSdkInitializationContentProviderHandlerAvailable(
            @NonNull AnylineSdkInitializationContentProviderHandler initializationHandler) {
        SdkInitializationParameters mySdkInitializationParameters =
                new SdkInitializationParameters("myLicenseKey");
        initializationHandler.proceedWithSdkInitializationParameters(mySdkInitializationParameters);
    }

    @Override
    public void onAnylineSdkInitializationContentProviderMessage(@NonNull String message) {
        Log.d("AnylineSdkInitProvider", message);
    }
}

If you have provided the requested parameters correctly and the SDK is still not initializing, please check if the provider io.anyline2.init.SdkInitializationContentProvider is merged into your application manifest.

Observing SDK initialization state

You can observe the initialization state of the SDK at any time using the initializationState LiveData object.

Kotlin
Java

AnylineSdk.initializationState.observe(this) { sdkInitializationState ->
    when (sdkInitializationState) {
        is SdkInitializationState.NotInitialized -> {
            sdkInitProgressBar.visibility = View.GONE
            startScanningButton.visibility = View.GONE
        }
        is SdkInitializationState.InProgress -> {
            sdkInitProgressBar.visibility = View.VISIBLE
            startScanningButton.visibility = View.GONE
        }
        is SdkInitializationState.Initialized -> {
            sdkInitProgressBar.visibility = View.GONE
            startScanningButton.visibility = View.VISIBLE
        }
    }
}

AnylineSdk.getInitializationState().observe(this, sdkInitializationState -> {
    if (sdkInitializationState instanceof SdkInitializationState.NotInitialized) {
        sdkInitProgressBar.setVisibility(View.GONE);
        startScanningButton.setVisibility(View.GONE);
    } else if (sdkInitializationState instanceof SdkInitializationState.InProgress) {
        sdkInitProgressBar.setVisibility(View.VISIBLE);
        startScanningButton.setVisibility(View.GONE);
    } else if (sdkInitializationState instanceof SdkInitializationState.Initialized) {
        sdkInitProgressBar.setVisibility(View.GONE);
        startScanningButton.setVisibility(View.VISIBLE);
    }
});

If you use any background initialization strategy, you must wait for the event onScanViewLoaded to occur before performing any operations with ScanView, since the SDK initialization may not yet be complete during the ScanView constructor. For more details, please see Initialize the ScanView.