Android SDK
Android project requirements
System requirements:
- minSdk = 26 (Android 8.0)
- compileSdk = 34
The SDK library was build using:
- Android Gradle Plugin 8.1.4
- Kotlin 1.9.24
Installing the library
- Add the maven repository in your project’s
settings.gradle.kts
file:
- Add the library as a dependency in your
app/build.gradle.kts
file:
Library dependencies
Impactful dependencies:
- Koin 3.2.2, including the implementation for Koin Context Isolation
- Compose BOM 2024.06.00 + Compose Compiler 1.5.14
- Accompanist 0.32.0
- Kotlin Coroutines 1.8.0
- OkHttp BOM 4.11.0
- Retrofit 2.9.0
- Coil Image Library 2.5.0
- Gson 2.11.0
Public API
The SDK library is managed through the FlowxSdkApi
singleton instance, which exposes the following methods:
Name | Description | Definition |
---|---|---|
init | Initializes the FlowX SDK. Must be called in your application’s onCreate() | fun init(context: Context, config: SdkConfig, accessTokenProvider: FlowxSdkApi.Companion.AccessTokenProvider? = null, customComponentsProvider: CustomComponentsProvider? = null, customStepperHeaderProvider: CustomStepperHeaderProvider? = null) |
setAccessTokenProvider | Updates the access token provider (i.e. a functional interface) inside the renderer | fun setAccessTokenProvider(accessTokenProvider: FlowxSdkApi.Companion.AccessTokenProvider) |
setupTheme | Sets up the theme to be used when rendering a process | fun setupTheme(themeUuid: String, fallbackThemeJsonFileAssetsPath: String? = null, @MainThread onCompletion: () -> Unit) |
changeLocaleSettings | Changes the current locale settings (i.e. locale and language) | fun changeLocaleSettings(locale: Locale, language: String) |
startProcess | Starts a FlowX process instance, by returning a @Composable function where the process is rendered. | fun startProcess(processName: String, params: JSONObject = JSONObject(), isModal: Boolean = false, closeModalFunc: ((processName: String) -> Unit)? = null): @Composable () -> Unit |
continueProcess | Continues an existing FlowX process instance, by returning a @Composable function where the process is rendered. | fun continueProcess(processUuid: String, isModal: Boolean = false, closeModalFunc: ((processName: String) -> Unit)? = null): @Composable () -> Unit |
executeAction | Runs an action from a custom component | fun executeAction(action: CustomComponentAction, params: JSONObject? = null) |
getMediaResourceUrl | Extracts a media item URL needed to populate the UI of a custom component | fun getMediaResourceUrl(key: String): String? |
replaceSubstitutionTag | Extracts a substitution tag value needed to populate the UI of a custom component | fun replaceSubstitutionTag(key: String): String |
Configuring the library
To configure the SDK, call the init
method in your project’s application class onCreate()
method:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
context | Android application Context | Context | Mandatory |
config | SDK configuration parameters | ai.flowx.android.sdk.process.model.SdkConfig | Mandatory |
accessTokenProvider | Functional interface provider for passing the access token | ai.flowx.android.sdk.FlowxSdkApi.Companion.AccessTokenProvder? | Optional. Defaults to null . |
customComponentsProvider | Provider for the @Composable /View custom components | ai.flowx.android.sdk.component.custom.CustomComponentsProvider? | Optional. Defaults to null . |
customStepperHeaderProvider | Provider for the @Composable custom stepper header view | ai.flowx.android.sdk.component.custom.CustomStepperHeaderProvider? | Optional. Defaults to null . |
• Providing the access token
is explained in the authentication section.
• The custom components
implementation is explained in its own section.
• The implementation for providing a custom view for the header
of the Stepper component is detailed in its own section.
Sample
The configuration properties that should be passed as SdkConfig
data for the config
parameter above are:
Name | Description | Type | Requirement |
---|---|---|---|
baseUrl | URL to connect to the FlowX back-end environment | String | Mandatory |
imageBaseUrl | URL to connect to the FlowX Media Library module of the CMS | String | Mandatory |
enginePath | URL path segment used to identify the process engine service | String | Mandatory |
language | The language used for retrieving enumerations and substitution tags | String | Optional. Defaults to en . |
locale | The locale used for date, number and currency formatting | java.util.Locale | Optional. Defaults to Locale.getDefault() |
validators | Custom validators for form elements | Map<String, (String) -> Boolean>? | Optional. |
enableLog | Flag indicating if logs should be printed | Boolean | Optional. Defaults to false |
Custom validators
The custom validators
map is a collection of lambda functions, referenced by name (i.e. the value of the key
in this map), each returning a Boolean
based on the String
which needs to be validated.
For a custom validator to be evaluated for a form field, its name must be specified in the form field process definition.
By looking at the example from above:
if a form element should be validated using this lambda function, a custom validator named "exact_25_in_length"
should be specified in the process definition.
Using the library
Authentication
To be able to use the SDK, authentication is required. Therefore, before calling any other method on the singleton instance, make sure that the access token provider is set by calling:
The lambda passed in as parameter has the ai.flowx.android.sdk.FlowxSdkApi.Companion.AccessTokenProvider
type, which is actually a functional interface defined like this:
setAccessTokenProvider
method again.Theming
access token provider
was set.Check the authentication section for details.
To be able to use styled components while rendering a process, the theming mechanism must be invoked by calling the suspend
-ing setupTheme(...)
method over the singleton instance of the SDK:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
themeUuid | UUID string of the theme configured in FlowX Designer | String | Mandatory. Can be empty |
fallbackThemeJsonFileAssetsPath | Android asset relative path to the corresponding JSON file to be used as fallback, in case fetching the theme fails and there is no cached version available | String? | Optional. Defaults to null |
onCompletion | @MainThread invoked closure, called when setting up the theme completes | () -> Unit | Mandatory |
If the themeUuid
parameter value is empty (""
), no theme will be fetched, and the mechanism will rely only on the fallback file, if set.
If the fallbackThemeJsonFileAssetsPath
parameter value is null
, there will be no fallback mechanism set in place, meaning if fetching the theme fails, the redered process will have no style applied over it’s displayed components.
The SDK caches the fetched themes, so if a theme fetch fails, a cached version will be used, if available. Otherwise, it will use the file given as fallback.
Sample
The fallbackThemeJsonFileAssetsPath
always search for files under your project’s assets/
directory, meaning the example parameter value is translated to file://android_asset/theme/a_fallback_theme.json
before being evaluated.
Changing current locale settings
The current locale
and language
can be also changed after the initial setup, by calling the changeLocaleSettings
function:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
locale | The new locale | java.util.Locale | Mandatory |
language | The code for the new language | String | Mandatory |
Sample
Start a FlowX process
After performing all the above steps and all the prerequisites are fulfilled, a new instance of a FlowX process can be started, by using the startProcess
function:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
applicationUuid | The uuid string of the application containing the process to be started | String | Mandatory |
processName | The name of the process | String | Mandatory |
params | The starting params for the process, if any | JSONObject | Optional. If omitted, if defaults to JSONObject() |
isModal | Flag indicating whether the process can be closed at anytime by tapping the top-right close button | Boolean | Optional. It defaults to false . |
onProcessEnded | Lambda function where you can do additional processing when the started process ends | (() -> Unit)? | Optional. It defaults to null . |
closeModalFunc | Lambda function where you should handle closing the process when isModal flag is true | ((processName: String) -> Unit)? | Optional. It defaults to null . |
The returned @Composable function must be included in its own Activity, which is part of (controlled and maintained by) the container application.
This wrapper activity must display only the @Composable
returned from the SDK (i.e. it occupies the whole activity screen space).
Sample
Resume a FlowX process
To resume an existing instance of a FlowX process, after fulfilling all the prerequisites, use the continueProcess
function:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
processUuid | The UUID string of the process | String | Mandatory |
isModal | Flag indicating whether the process can be closed at anytime by tapping the top-right close button | Boolean | Optional. It defaults to false . |
onProcessEnded | Lambda function where you can do additional processing when the continued process ends | (() -> Unit)? | Optional. It defaults to null . |
closeModalFunc | Lambda function where you should handle closing the process when isModal flag is true | ((processName: String) -> Unit)? | Optional. It defaults to null . |
The returned @Composable function must be included in its own Activity, which is part of (controlled and maintained by) the container application.
This wrapper activity must display only the @Composable
returned from the SDK (i.e. it occupies the whole activity screen space).
Sample
Custom components
The container application should decide which custom component view to provide using the componentIdentifier
configured in the UI designer.
A custom component receives data
to populate the view and actions
available to execute, as described below.
To handle custom components, an implementation of the CustomComponentsProvider
interface should be passed as a parameter when initializing the SDK:
There are two methods to provide a custom component:
- by implementing the CustomComposableComponent interface
- by implementing the CustomViewComponent interface
Sample
CustomComposableComponent
To provide the custom component as a @Composable function, you have to implement the CustomComposableComponent
interface:
The returned CustomComposable
object is an interface defined like this:
The value for the data
parameter received in the populateUi(data: Any?)
could be:
Boolean
String
java.lang.Number
org.json.JSONObject
org.json.JSONArray
The appropriate way to check and cast the data accordingly to the needs must belong to the implementation details of the custom component.
Sample
CustomViewComponent
To provide the custom component as a classical Android View function, you have to implement the CustomViewComponent
interface:
The returned CustomView
object is an interface defined like this:
The value for the data
parameter received in the populateUi(data: Any?)
could be:
Boolean
String
java.lang.Number
org.json.JSONObject
org.json.JSONArray
The appropriate way to check and cast the data accordingly to the needs must belong to the implementation details of the custom component.
Sample
Execute action
The custom components which the container app provides may contain FlowX actions available for execution.
These actions are received through the actions
parameter of the populateUi(actions: Map<String, CustomComponentAction>)
method.
In order to run an action (i.e. on a click of a button in the custom component) you need to call the executeAction
method:
Parameters
Name | Description | Type | Requirement |
---|---|---|---|
action | Action object extracted from the actions received in the custom component | ai.flowx.android.sdk.component.custom.CustomComponentAction | Mandatory |
params | Parameters needed to execute the action | JSONObject? | Optional. It defaults to null |
Get a substitution tag value by key
All substitution tags will be retrieved by the SDK before starting the process and will be stored in memory.
Whenever the container app needs a substitution tag value for populating the UI of the custom components, it can request the substitution tag using the method above, by providing the key
.
It returns:
- the key’s counterpart, if the
key
is valid and found - the empty string, if the
key
is valid, but not found - the unaltered string, if the key has the wrong format (i.e. not starting with
@@
)
Get a media item url by key
All media items will be retrieved by the SDK before starting the process and will be stored in memory.
Whenever the container app needs a media item url for populating the UI of the custom components, it can request the url using the method above, by providing the key
.
It returns the URL
string of the media resource, or null
, if not found.
Custom header view for the STEPPER component
The container application can opt for providing a custom view in order to be used, for all the Stepper components, as a replacement for the built-in header.
The custom view receives data
to populate its UI, as described below.
To provide a custom header for the Stepper, an implementation of the CustomStepperHeaderProvider
interface should be passed as a parameter when initializing the SDK:
As opposed to the Custom components, the only supported way is by providing the view as a @Composable function.
Sample
CustomComposableStepperHeader
To provide the custom header view as a @Composable function, you have to implement the CustomComposableStepperHeader
interface:
The returned ComposableStepperHeader
object is an interface defined like this:
The value for the data
parameter received as function argument is an interface defined like this:
Sample
Known issues
- shadows are rendered only on Android >= 28 having hardware acceleration enabled
- there is no support yet for subprocesses started using the Call Activity node when configuring a TabBar Navigation Area
Was this page helpful?