Zebra DataWedge

https://techdocs.zebra.com/datawedge/
Admin
Zebra DataWedge is an application service that streamlines data capture from barcode scanners,...
Tokens:292,773
Snippets:1,486
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Get Weight Example (GET_WEIGHT)

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getweight

Example method to retrieve the weight from the MP7000 scale. Uses DEVICE_IDENTIFIER "USB_TGCS_MP7000" and COMMAND "GET_WEIGHT". Sends a broadcast with the SCALE bundle.

```java
    void getWeightAPICall()
    {
        Bundle bundleScale = new Bundle();
        Bundle bundleScaleConfig = new Bundle();
        bundleScaleConfig.putString("DEVICE_IDENTIFIER", "USB_TGCS_MP7000");
        bundleScaleConfig.putString("COMMAND", "GET_WEIGHT");
        bundleScale.putBundle("SCALE_CONFIG", bundleScaleConfig);

        Intent i = new Intent();
        i.setAction(DATAWEDGE_API_ACTION);
        i.setPackage(DATAWEDGE_PACKAGE);
        i.putExtra("SEND_RESULT","true");
        i.putExtra("com.symbol.datawedge.api.SCALE", bundleScale);
        sendBroadcast(i);
    }

```

--------------------------------

### Example: Switch to Scanner 3

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/switchscanner

Example code showing how to switch to scanner index 3 and receive result codes.

```APIDOC
## Example: Switch to Scanner 3

### Description
Example code showing how to switch to scanner index 3 and receive result codes.

### Method
Intent Broadcast

### Endpoint
Action: "com.symbol.datawedge.api.ACTION"
Extra: "com.symbol.datawedge.api.SWITCH_SCANNER"

### Parameters
#### Intent Extras
- **ACTION** (String) - Required - "com.symbol.datawedge.api.ACTION"
- **EXTRA_DATA** (String) - Required - "com.symbol.datawedge.api.SWITCH_SCANNER"
- **EXTRA_DATA** (String) - Required - "3" - scanner index
- **SEND_RESULT** (String) - Optional - "true" to enable result codes
- **COMMAND_IDENTIFIER** (String) - Optional - "123456789" - identifier for the command

### Request Example
```java
String scannerIndex = "3";

// create the intent and action
Intent i = new Intent();
i.setAction("com.symbol.datawedge.api.ACTION");
i.putExtra("com.symbol.datawedge.api.SWITCH_SCANNER", scannerIndex);

// generate result codes
i.putExtra("SEND_RESULT","true");
i.putExtra("COMMAND_IDENTIFIER","123456789");

// send the intent
this.sendBroadcast(i);
```

### Response
#### Result Codes
DataWedge returns the following error codes if the app includes the intent extras `SEND_RESULT` and `COMMAND_IDENTIFIER` to enable the app to get results using the DataWedge result intent mechanism.
- **DATAWEDGE_DISABLED** - DataWedge is disabled
- **NO_ACTIVE_PROFILE** - No Profile is active
- **PARAMETER_INVALID** - Given scanner parameter is invalid
- **PLUGIN_DISABLED** - Scanner plug-in is disabled
- **PROFILE_DISABLED** - Profile is disabled
- **SCANNER_ALREADY_ENABLED** - Scanner is disabled
- **SCANNER_DISABLE_FAILED** - Scanner is disabled
- **SCANNER_NOT_CONNECTED** - Scanner is not connected

```

--------------------------------

### createProfile() Example

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/createprofile

Example method that creates a DataWedge profile using the CREATE_PROFILE intent. The profile name is passed as a variable.

```java
private void createProfile() {
    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.CREATE_PROFILE", profileName);
    this.sendBroadcast(i);
}
```

--------------------------------

### Example Code: Send Intent and Process Disabled App List

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getdisabledapplist

Complete example that sends the GET_DISABLED_APP_LIST intent, receives the result in onReceive, and logs the package names and activities.

```java
// create the intent and action
    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.GET_DISABLED_APP_LIST","");

// send the intent
    this.sendBroadcast(i);

// process the results inside onReceive callback
    ArrayList<Bundle> disabledAppList  = new ArrayList<>();
    if(intent.hasExtra("com.symbol.datawedge.api.RESULT_GET_DISABLED_APP_LIST"))
        disabledAppList = intent.getParcelableArrayListExtra("com.symbol.datawedge.api.RESULT_GET_DISABLED_APP_LIST");

    if(disabledAppList!= null && disabledAppList.size() > 0){
        for (Bundle bundle:disabledAppList) {
            String packageName = bundle.getString("PACKAGE_NAME");

            ArrayList<String> activityList = new ArrayList<>();
            activityList =bundle.getStringArrayList("ACTIVITY_LIST");

            Log.d("TAG","PackageName: " + packageName);
            for(String activityName : activityList){
                Log.d("TAG","\t\t\tActivity: " + activityName);
            }
        }
    }
    else{
        Log.d("TAG","Disabled app list is empty");
        }
```

--------------------------------

### SET_IGNORE_DISABLED_PROFILES Implementation Example

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/setignoredisabledprofiles

A complete example demonstrating how to send the intent, request a result, and register a broadcast receiver to handle the response.

```java
//Sample code for sending the intent to SET the setting
    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.SET_IGNORE_DISABLED_PROFILES","true");

// request and identify the result code
    i.putExtra("SEND_RESULT","true");
    i.putExtra("COMMAND_IDENTIFIER","123456789");//user specified unique id

    this.sendBroadcast(i);

// Register/unregister broadcast receiver and filter results

    void registerReceivers() {
            IntentFilter filter = new IntentFilter();
            filter.addAction("com.symbol.datawedge.api.RESULT_ACTION");
            filter.addCategory("android.intent.category.DEFAULT");
            registerReceiver(mybroadcastReceiver, filter);
    }

    void unRegisterReceivers(){
            unregisterReceiver(mybroadcastReceiver);
    }
        //receiving the results
            BroadcastReceiver mybroadcastReceiver = new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    String command = intent.getStringExtra("COMMAND");
                    String commandIdentifier = intent.getStringExtra("COMMAND_IDENTIFIER");
                    String result = intent.getStringExtra("RESULT");

        Bundle bundle;
        String resultInfo = "";
        if(intent.hasExtra("RESULT_INFO")){
            bundle = intent.getBundleExtra("RESULT_INFO");
            Set<String> keys = bundle.keySet();
            for (String key: keys) {
                Object object = bundle.get(key);
                if(object instanceof String){
                    resultInfo += key + ": "+object+ "\n";
                }
                else if(object instanceof String[]){
                    String[] codes = (String[])object;
                    for(String code : codes){
                        resultInfo += key + ": "+code+ "\n";
                    }
                }
            }
        }

        String text = "Command: "+command+"\n" +
            "Result: " +result+"\n" +
            "Result Info: " +resultInfo + "\n" +
            "CID:"+commandIdentifier;

           Log.d(TAG,text);

    }
};
```

--------------------------------

### SOFT_TRIGGER Example Code

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/softtrigger

Example of sending a SOFT_TRIGGER command with START parameter. Uses PLUGIN_NAME "VOICE" and COMMAND_IDENTIFIER "VOICE_TRIGGER". Sends broadcast without mContext prefix.

```java
Intent i = new Intent();
i.setPackage("com.symbol.datawedge");
i.setAction("com.symbol.datawedge.api.ACTION");
i.putExtra("SEND_RESULT","LAST_RESULT");
i.putExtra("PLUGIN_NAME", "VOICE");
i.putExtra("com.symbol.datawedge.api.SOFT_TRIGGER", "START"); //START, STOP
i.putExtra("COMMAND_IDENTIFIER", "VOICE_TRIGGER");
sendBroadcast(i);
```

--------------------------------

### Example Code for Sending GET_IGNORE_DISABLED_PROFILES Intent

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getignoredisabledprofiles

Sample code to send the intent to GET the setting, including setting SEND_RESULT and COMMAND_IDENTIFIER, and registering/unregistering a broadcast receiver to receive the result.

```java
    //Sample code for sending the intent to GET the setting
        Intent i = new Intent();
        i.setAction("com.symbol.datawedge.api.ACTION");
        i.putExtra("com.symbol.datawedge.api.GET_IGNORE_DISABLED_PROFILES","");

    // request and identify the result code
        i.putExtra("SEND_RESULT","true");
        i.putExtra("COMMAND_IDENTIFIER","123456789");//user specified unique id

        this.sendBroadcast(i);

// Register/unregister broadcast receiver and filter results

    void registerReceivers() {
        IntentFilter filter = new IntentFilter();
        filter.addAction("com.symbol.datawedge.api.RESULT_ACTION");
        filter.addCategory("android.intent.category.DEFAULT");
        registerReceiver(mybroadcastReceiver, filter);
    }

    void unRegisterReceivers(){
        unregisterReceiver(mybroadcastReceiver);
    }
```

--------------------------------

### Set configuration for multiple modules (full profile) in a single intent

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/setconfig

Builds a full profile configuration for multiple DataWedge modules (Intent, Barcode, SimulScan, MSR, IP Output, Token) and an app list, all bundled into a single intent. The example shows how to set token order parameters and app list entries.

```java
Bundle tokenOrder_serial_number = new Bundle();
        tokenOrder_serial_number.putString("name","serial_number");
        tokenOrder_serial_number.putString("enabled","true");

        Bundle tokenOrder_mpho_lot_number = new Bundle();
        tokenOrder_mpho_lot_number.putString("name","mpho_lot_number");
        tokenOrder_mpho_lot_number.putString("enabled","true");

        Bundle tokenOrder_donation_id = new Bundle();
        tokenOrder_donation_id.putString("name","donation_id");
        tokenOrder_donation_id.putString("enabled","true");

        Bundle tokenOrder_labeler_identification_code = new Bundle();
        tokenOrder_labeler_identification_code.putString("name","labeler_identification_code");
        tokenOrder_labeler_identification_code.putString("enabled","true");

        Bundle tokenOrder_product_or_catalog_number = new Bundle();
        tokenOrder_product_or_catalog_number.putString("name","product_or_catalog_number");
        tokenOrder_product_or_catalog_number.putString("enabled","true");

        Bundle tokenOrder_unit_of_measure_id = new Bundle();
        tokenOrder_unit_of_measure_id.putString("name","unit_of_measure_id");
        tokenOrder_unit_of_measure_id.putString("enabled","true");

        Bundle tokenOrder_quantity = new Bundle();
        tokenOrder_quantity.putString("name","quantity");
        tokenOrder_quantity.putString("enabled","false");

        ArrayList<Bundle> tokenOrderList = new ArrayList<>();
        tokenOrderList.add(tokenOrder_manufacturing_date_original);
        tokenOrderList.add(tokenOrder_expiration_date_original);
        tokenOrderList.add(tokenOrder_lot_number);
        tokenOrderList.add(tokenOrder_di);
        tokenOrderList.add(tokenOrder_serial_number);
        tokenOrderList.add(tokenOrder_mpho_lot_number);
        tokenOrderList.add(tokenOrder_donation_id);
        tokenOrderList.add(tokenOrder_labeler_identification_code);
        tokenOrderList.add(tokenOrder_product_or_catalog_number);
        tokenOrderList.add(tokenOrder_unit_of_measure_id);
        tokenOrderList.add(tokenOrder_quantity);

        bParamsToken.putParcelableArrayList("token_order", tokenOrderList);

        bConfigToken.putString("PLUGIN_NAME", "TOKEN");
        bConfigToken.putString("OUTPUT_PLUGIN_NAME","IP");
        bConfigToken.putString("RESET_CONFIG", "true");
        bConfigToken.putBundle("PARAM_LIST", bParamsToken);

        ArrayList<Bundle> bundlePluginConfig = new ArrayList<>();
        bundlePluginConfig.add(bConfigIntent);
        bundlePluginConfig.add(bConfigBarcode);
        bundlePluginConfig.add(bConfigSimulScan);
        bundlePluginConfig.add(bConfigMSR);
        bundlePluginConfig.add(bConfigIPOutput);
        bundlePluginConfig.add(bConfigToken);

        bMain.putParcelableArrayList("PLUGIN_CONFIG", bundlePluginConfig);

        //AppList[Start]
        Bundle bundleApp1 = new Bundle();
        bundleApp1.putString("PACKAGE_NAME", "com.symbol.emdk.simulscansample1");
        bundleApp1.putStringArray("ACTIVITY_LIST", new String[]{
                        "com.symbol.emdk.simulscansample1.DeviceControl",
                        "com.symbol.emdk.simulscansample1.MainActivity",
                        "com.symbol.emdk.simulscansample1.ResultsActivity",
                        "com.symbol.emdk.simulscansample1.ResultsActivity2",
                        "com.symbol.emdk.simulscansample1.SettingsFragment1"});

        Bundle bundleApp2 = new Bundle();
        bundleApp2.putString("PACKAGE_NAME", "com.example.intents.datawedgeintent");
        bundleApp2.putStringArray("ACTIVITY_LIST", new String[]{
                        "com.example.intents.datawedgeintent.DeviceControl",
                        "com.example.intents.datawedgeintent.MainActivity",
                        "com.example.intents.datawedgeintent.ResultsActivity",
                        "com.example.intents.datawedgeintent.SettingsFragment1"});

        Bundle bundleApp3 = new Bundle();
        bundleApp3.putString("PACKAGE_NAME", "com.symbol.pubudu");
        bundleApp3.putStringArray("ACTIVITY_LIST", new String[]{"*"});

        Bundle bundleApp4 = new Bundle();
        bundleApp4.putString("PACKAGE_NAME", "com.symbol.myzebraapp");
        bundleApp4.putStringArray("ACTIVITY_LIST", new String[]{"*"});

        // ADD APP_LIST BUNDLE(S) INTO THE MAIN BUNDLE
        bMain.putParcelableArray("APP_LIST", new Bundle[]{
                        bundleApp1
                        , bundleApp2
                        , bundleApp3
                        , bundleApp4
        });

        // AppList [End]
```

--------------------------------

### Get Full Profile Configuration in a Single Intent

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getconfig

Sends a GET_CONFIG intent with a profile name to retrieve the full profile configuration (all modules) in one call. Supported starting with DataWedge 7.1; earlier versions required multiple intent calls. The result is processed in a BroadcastReceiver.

```java
// Get full profile configuration in a single broadcast intent and process the result

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    IntentFilter filter = new IntentFilter();
    filter.addAction("com.symbol.datawedge.api.RESULT_ACTION");
    filter.addCategory("android.intent.category.DEFAULT");
    registerReceiver(broadcastReceiver, filter);
    getConfig();
}

public void getConfig() {

    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.GET_CONFIG",  "Profile007");
    this.sendBroadcast(i);
}

private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        String strFinalResult = "";

        if (action.equals("com.symbol.datawedge.api.RESULT_ACTION")) {

            if (intent.hasExtra("com.symbol.datawedge.api.RESULT_GET_CONFIG")) {

                Bundle resultGetConfig = intent.getBundleExtra("com.symbol.datawedge.api.RESULT_GET_CONFIG");
                Set<String> keys = resultGetConfig.keySet();
                String profileName = resultGetConfig.getString("PROFILE_NAME");


                for (String key : keys) {

```

--------------------------------

### Send GET_CONFIG Intent

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getconfig

Builds a bundle with PROFILE_NAME and PLUGIN_CONFIG for the TOKEN plugin, then sends a broadcast with the GET_CONFIG extra. Tokens are supported only in KEYSTROKE and IP plugins; others return an empty bundle.

```java
public void getConfig() {
    Bundle bMain = new Bundle();
    bMain.putString("PROFILE_NAME", "Profile007");
    Bundle bConfig = new Bundle();

    Bundle processPlugin_TOKEN_IP = new Bundle();
    processPlugin_TOKEN_IP.putString("PLUGIN_NAME", "TOKEN");
    processPlugin_TOKEN_IP.putString("OUTPUT_PLUGIN_NAME", "KEYSTROKE"); // Tokens are supported only in KEYSTROKE and IP plugins only, for others empty bundle will be returned.

    bConfig.putBundle("PROCESS_PLUGIN_NAME", processPlugin_TOKEN_IP);

    bMain.putBundle("PLUGIN_CONFIG", bConfig);
    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.GET_CONFIG", bMain);
    this.sendBroadcast(i);
}

private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
```

--------------------------------

### CREATE_PROFILE Function Prototype

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/createprofile

Shows the basic intent setup to create a DataWedge profile. The profile name is passed as an empty string in the prototype.

```java
Intent i = new Intent();
i.setAction("com.symbol.datawedge.api.ACTION");
i.putExtra("com.symbol.datawedge.api.CREATE_PROFILE", "");
```

--------------------------------

### Get SIMULSCAN configuration with DataWedge API

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/getconfig

Sends a GET_CONFIG intent for the SIMULSCAN plugin of a specified profile and handles the result in a BroadcastReceiver. The receiver parses the returned configuration, including dynamic template parameters, and logs the result. The example includes both the method to send the intent and the receiver that processes the response.

```java
public void getConfig()
{
    Bundle bMain = new Bundle();
    bMain.putString("PROFILE_NAME", "Profile007");
    Bundle bConfig = new Bundle();
    ArrayList<String> pluginName = new ArrayList<>();
    pluginName.add("SIMULSCAN");

    bConfig.putStringArrayList("PLUGIN_NAME", pluginName);
    bMain.putBundle("PLUGIN_CONFIG", bConfig);
    Intent i = new Intent();
    i.setAction("com.symbol.datawedge.api.ACTION");
    i.putExtra("com.symbol.datawedge.api.GET_CONFIG", bMain);
    this.sendBroadcast(i);
}

private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        String strFinalResult = "";
        String command = intent.getStringExtra("COMMAND");
        String commandidentifier = intent.getStringExtra("COMMAND_IDENTIFIER");
        String result = intent.getStringExtra("RESULT");
        Bundle bundle = new Bundle();
        String resultInfo = "";

        if (action.equals("com.symbol.datawedge.api.RESULT_ACTION")) {

            if (intent.hasExtra("RESULT_INFO")) {
                bundle = intent.getBundleExtra("RESULT_INFO");
                Set<String> keys = bundle.keySet();
                for (String key : keys) {
                    String val = bundle.getString(key);
                    if(val == null) {

                        if(bundle.getStringArray(key) != null) {
                            val="";
                            for (String s : bundle.getStringArray(key)) {
                                val += "" + s + "\n";
                            }
                        }
                    }

                    resultInfo += key + ": " + val + "\n";
                }

            } else if (intent.hasExtra("com.symbol.datawedge.api.RESULT_GET_CONFIG")) {

                Bundle resultGetConfig = intent.getBundleExtra("com.symbol.datawedge.api.RESULT_GET_CONFIG");
                Set<String> keys = resultGetConfig.keySet();
                String profileName = resultGetConfig.getString("PROFILE_NAME");
                for (String key : keys) {
                    if (key.equalsIgnoreCase("PLUGIN_CONFIG")) {
                        ArrayList<Bundle> bundleArrayList = resultGetConfig.getParcelableArrayList("PLUGIN_CONFIG");
                        for (Bundle configBundle : bundleArrayList) {

                                strFinalResult += "\nPlugin " + configBundle.getString("PLUGIN_NAME") + " Settings\n";
                                for (String configBundleKey : configBundle.keySet()) {
                                    if (configBundleKey.equalsIgnoreCase("PARAM_LIST")) {

                                        Bundle params = configBundle.getBundle("PARAM_LIST");

                                        for (String paramKey :  params.keySet()) {

                                            if(paramKey.equalsIgnoreCase("simulscan_template_params")) {
                                                Bundle simulscan_template_params = params.getBundle("simulscan_template_params");
                                                if (simulscan_template_params != null) {
                                                    strFinalResult += "\n\tDynamic template params";
                                                    for (String template_param : simulscan_template_params.keySet()) {
                                                        strFinalResult += "\n\t\t" + template_param + ": " + simulscan_template_params.get(template_param);
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                strFinalResult += "\n\t" + paramKey + ": " + params.get(paramKey);
                                            }

                                        }
                                    }
                                }
                                strFinalResult += "\n";
                        }
                    }
                }
                Log.d("TAG","#IntentApp#\n\nGet config info received\n" + strFinalResult);
            }

            if (command != null) {
                if (command.equalsIgnoreCase("com.symbol.datawedge.api.SET_CONFIG")) {
                    Log.d("TAG","#IntentApp# \n\nSetConfig status received: " + result + "\nResultInfo: " + resultInfo);
                }
            }
        }
    }
};
```

--------------------------------

### Example Code: Register Receiver, Send Intent, and Handle Result

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/enumerateworkflows

Complete example showing how to register a broadcast receiver for the result action, send the ENUMERATE_WORKFLOWS intent, and process the returned workflow list. The receiver checks for the 'com.symbol.datawedge.api.RESULT_ENUMERATE_WORKFLOWS' extra and logs the workflow IDs and names.

```java
    /*Call before sending the enumerate workflows query*/
    private void registerReceivers() {
        IntentFilter filter = new IntentFilter();
        filter.addAction("com.symbol.datawedge.api.RESULT_ACTION");
        filter.addCategory(Intent.CATEGORY_DEFAULT);
        registerReceiver(broadcastReceiver, filter);
    }

    /* Send the enumerate workflows command to DataWedge intent API*/
    private void enumerateWorkflows() {
        Intent intent = new Intent();
        intent.setAction("com.symbol.datawedge.api.ACTION");
        intent.putExtra("com.symbol.datawedge.api.ENUMERATE_WORKFLOWS", "");
        sendBroadcast(intent);
    }

    /*unregister the broadcast receiver*/
    private void unRegisterReceivers() {
        unregisterReceiver(broadcastReceiver);
    }

    /*Create broadcast receiver to receive the enumerate workflows result*/
    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.d("EnumerateWorkflows", "Action: " + action);
            if (action.equals("com.symbol.datawedge.api.RESULT_ACTION")) {
                if (intent.hasExtra("com.symbol.datawedge.api.RESULT_ENUMERATE_WORKFLOWS")) {
                    Bundle workflowBundle = (Bundle) intent.getExtras().get("com.symbol.datawedge.api.RESULT_ENUMERATE_WORKFLOWS");
                    String strData = "";
                    int count = 1;
                    ArrayList<String> workflowList = new ArrayList<>();
                    if (workflowBundle != null) {
                        for (String key : workflowBundle.keySet()) {
                            String value = workflowBundle.getString(key);
                            if (value != null) {
                                String listItem = count + ") " +key +" - "+ value;
                                workflowList.add(listItem);
                                strData += listItem + "\n";
                                count++;
                            }
                        }
                        Log.d("EnumerateWorkflows",strData );
                    }
                }
            }
        }
    };
```

--------------------------------

### Set configuration for multiple modules in a single intent

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/setconfig

Sets configuration for multiple modules (plugins, APP_LIST, and Data Capture Plus) in a single SET_CONFIG intent. This capability is supported starting with DataWedge 7.1; earlier versions required multiple intent calls. The example registers a broadcast receiver for RESULT_ACTION and calls setConfig() in onCreate.

```java
@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        IntentFilter filter = new IntentFilter();
        filter.addAction("com.symbol.datawedge.api.RESULT_ACTION");
        filter.addCategory("android.intent.category.DEFAULT");
        registerReceiver(broadcastReceiver, filter);
        setConfig();
}

public void setConfig() {

        /**
        * Setting configuration for:
        * Intent Output Plugin
        * Barcode Input Plugin
        * MSR input Plugin
        * IP Output Plugin
        * Tokens for IP Output Plugin
        * Application Association
        * DCP (Data Capture Plus)
        */

        // SetConfig [Start]
        Bundle bMain = new Bundle();
```

--------------------------------

### getExternalFilesDirs Example

Source: https://techdocs.zebra.com/datawedge/latest/guide/api/importconfig

Zebra recommends using getExternalFilesDirs to identify accessible external storage locations before sending the IMPORT_CONFIG intent. The example shows the call and an example return with three storage paths.

```java
File[] fileDirs = getExternalFilesDirs(null);
```

```text
/storage/34E4-1117/Android/data/<PackageName>/files
/storage/sdcard2/0/Android/data/<PackageName>/files
/storage/emulated/0/Android/data/<PackageName>/files
```
Tokens:
Raw