Bundle option = new Bundle(); // optional
 option.putInt(PeripheralConstants.BeepSoundEffect.INTERVAL_INT, 500); // optional
 option.putInt(PeripheralConstants.BeepSoundEffect.REPEAT_INT, 3); // optional
 // option is 'repeat 3 times, interval is 500 milliseconds

 PeripheralManager.getInstance(context).beep(mPeripheralId, milliseconds, option,
     new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'beep' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'beep' function failed
         }
 });
 

 PeripheralManager.getInstance(context).clearMemory(peripheralId, clearOption
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'clearMemory' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'clearMemory' function failed
         }
 });
 

 mPeripheralManager.connectPeripheral(device,
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'connectPeripheral' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'connectPeripheral' function failed
         }
 });
 

 mPeripheralManager.disconnectPeripheral(peripheralId,
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'disconnectPeripheral' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'disconnectPeripheral' function failed
         }
 });
 

 Bundle option = new Bundle(); // optional
 option.putBoolean(PeripheralConstants.DisplayText.CLEAR_DISPLAY_BOOL, false); // optional

 PeripheralManager.getInstance(context).displayText(mPeripheralId, text, milliseconds, option,
     new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'displayText' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'displayText' function failed
         }
 });
 

 // if peripheralService is enabled, disable peripheralService to change profile.
 if (PeripheralManager.getInstance(context).isEnabled()) {
     PeripheralManager.getInstance(context).disable();
 }
 PeripheralManager.getInstance(context).enable(getProfile());

 private Bundle getProfile() {
   Bundle bundle = new Bundle();
   bundle.putString(KEY_PROFILE_NAME_STR, "test_profile_2021-01-11");
   Bundle pluginBundle = getPlugin();
   ArrayList pluginList = new ArrayList<>();
   pluginList.add(pluginBundle);
   bundle.putParcelableArrayList(KEY_PLUGIN_BUNDLE_LIST, pluginList);
   return bundle;
 }

 private Bundle getPlugin() {
   Bundle bundle = new Bundle();
   bundle.putString(KEY_PLUGIN_NAME_STR, "plugin_name");
   bundle.putString(KEY_PLUGIN_PACKAGE_NAME_STR, "com.test.test_plugin");
   bundle.putString(KEY_PLUGIN_SERVICE_NAME_STR, "com.test.test_plugin.plugin_service");
   Bundle peripheralBundle = getPeripheral();
   ArrayList peripheralList = new ArrayList<>();
   peripheralList.add(peripheralBundle);
   bundle.putParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST, peripheralList);
   return bundle;
 }

 private Bundle getPeripheral() {
   Bundle bundle = new Bundle();
   bundle.putString(KEY_PERIPHERAL_NAME_STR, "test_peripheral");
   Bundle connectivityBundle = getConnectivity();
   ArrayList connectivityList = new ArrayList<>();
   connectivityList.add(connectivityBundle);
   bundle.putParcelableArrayList(KEY_PERIPHERAL_CONNECTIVITY_BUNDLE_LIST, connectivityList);
   return bundle;
 }

 private Bundle getConnectivity() {
   Bundle bundle = new Bundle();
   bundle.putString(KEY_PERIPHERAL_CONNECTIVITY_TYPE_STR,
           PeripheralConstants.ConnectivityType.USB);
   bundle.putString(KEY_PERIPHERAL_CONNECTIVITY_IDENTIFIER_STR,"SPP:1111/3333,HID:2222/3333");
   bundle.putString(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR,
           PeripheralConstants.BarcodeDataProcessMode.WEDGE);
   bundle.putString(KEY_PERIPHERAL_PREFIX_STR, "test_prefix");
   bundle.putString(KEY_PERIPHERAL_SUFFIX_STR, "test_suffix");
   bundle.putBoolean(KEY_PERIPHERAL_BARCODE_ENABLE_TIMESTAMP_BOOL, true);
   bundle.putBoolean(KEY_PERIPHERAL_ENABLE_BEEP_SOUND_BOOL, true);
   ArrayList symbolList = new ArrayList<>();
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODABAR);
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODE11);
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODE32);
   symbolList.add(PeripheralBarcodeConstants.Symbology.EAN13);
   bundle.putStringArrayList(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_LIST, symbolList);
   return bundle;
 }
 

 public void getAvailablePeripheral(Context context) {
     PeripheralManager peripheralManager = PeripheralManager.getInstance(context);
     peripheralManager.getAvailablePeripherals(new PeripheralResultListener() {
         public void onSuccess(Bundle bundle) {
             getPeripheralList(bundle);
         }
         public void onFail(int errorCode, String description) {
             // invoked if fail to call getAvailablePeripheral.
         }
     });
 }
 private List getPeripheralList(Bundle bundle) {
     ArrayList pluginList = new ArrayList<>();
     ArrayList pluginBundleList = bundle.getParcelableArrayList(KEY_PLUGIN_BUNDLE_LIST);

     if (pluginBundleList == null) return pluginList;
     for (Bundle plugin : pluginBundleList) {
         ArrayList peripherals =
                 plugin.getParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST);
         if (peripherals == null) continue;
         for (Bundle peripheral : peripherals) {
             String peripheralId = peripheral.getString(KEY_PERIPHERAL_ID_STR);
             pluginList.add(peripheralId);
         }
     }
     return pluginList;
 }
 

 mPeripheralManager.getBluetoothPeripherals(PeripheralConstants.BtPeripheralListOption.ALL,
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'getBluetoothPeripherals' function succeeds
             ArrayList btList = bundle.getParcelableArrayList(PeripheralConstants.KEY_RESULT_BLUETOOTH_PERIPHERAL_LIST);
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'getBluetoothPeripherals' function failed
         }
 });
 

 private void getConfiguration(Context context, String peripheralId) {
   ArrayList list = new ArrayList<>();
   list.add(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR);
   list.add(KEY_PERIPHERAL_PREFIX_STR);
   list.add(KEY_PERIPHERAL_SUFFIX_STR);
   list.add(KEY_PERIPHERAL_BARCODE_ENABLE_TIMESTAMP_BOOL);
   list.add(KEY_PERIPHERAL_ENABLE_BEEP_SOUND_BOOL);
   list.add(KEY_PERIPHERAL_ENABLE_CHECK_DUPLICATED_BARCODE_BOOL);
   list.add(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_LIST);
   list.add(KEY_PERIPHERAL_BARCODE_SUPPORTED_SYMBOLOGY_LIST);
   list.add(KEY_PERIPHERAL_BATTERY_LEVEL_STR);
   list.add(KEY_PERIPHERAL_CONNECTIVITY_TYPE_STR);
   list.add(KEY_PERIPHERAL_FIRMWARE_STR);
   list.add(KEY_PERIPHERAL_MANUFACTURER_STR);
   list.add(KEY_PERIPHERAL_NAME_STR);
   list.add(KEY_PERIPHERAL_SERIAL_NUMBER_STR);
   list.add(KEY_PERIPHERAL_STORED_DATA_COUNT_INT);
   list.add(KEY_PERIPHERAL_TYPE_STR);
   list.add(KEY_PLUGIN_VENDOR_STR);
   list.add(KEY_PLUGIN_VERSION_STR);
   list.add(KEY_PLUGIN_PACKAGE_NAME_STR);
   list.add(KEY_PLUGIN_SERVICE_NAME_STR);
   // getConfiguration doesn't support below fields. please find them by using getInformation()
   //list.add(KEY_RESULT_CURRENT_CONNECTIVITY_TYPE_STR);
   //list.add(KEY_RESULT_CURRENT_CONNECTIVITY_VERSION_STR);
   PeripheralManager.getInstance(context).
      getConfiguration(peripheralId, list,
           new PeripheralResultListener(){
               public void onSuccess(Bundle bundle) {
                   onGetConfiguration(bundle);
               }
               public void onFail(int errorCode, String description) {
                   // invoked if fail to call setConfiguration.
               }
           });
 }

 private void onGetConfiguration(Bundle bundle) {

   ArrayList peripheralList = bundle.getParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST);

   for (Bundle peripheral : peripheralList) {
       // barcodeDataProcessMode is matched PeripheralConstants.BarcodeDataProcessMode
       String barcodeDataProcessMode
                     = peripheral.getString(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR);
       boolean enableTimestamp =
                     peripheral.getBoolean(KEY_PERIPHERAL_BARCODE_ENABLE_TIMESTAMP_BOOL);
       String batteryLevel = peripheral.getString(KEY_PERIPHERAL_BATTERY_LEVEL_STR);
       // connectivityType is matched with PeripheralConstants.ConnectivityType
       String connectivityType = peripheral.getString(KEY_PERIPHERAL_CONNECTIVITY_TYPE_STR);
       boolean enableBeepSound = peripheral.getBoolean(KEY_PERIPHERAL_ENABLE_BEEP_SOUND_BOOL);
       String firmware = peripheral.getString(KEY_PERIPHERAL_FIRMWARE_STR);
       String manufacturer = peripheral.getString(KEY_PERIPHERAL_MANUFACTURER_STR);
       String peripheralName = peripheral.getString(KEY_PERIPHERAL_NAME_STR);
       String prefix = peripheral.getString(KEY_PERIPHERAL_PREFIX_STR);
       String suffix = peripheral.getString(KEY_PERIPHERAL_SUFFIX_STR);
       String serialNumber = peripheral.getString(KEY_PERIPHERAL_SERIAL_NUMBER_STR);
       String vendor = peripheral.getString(KEY_PLUGIN_VENDOR_STR);
       String version = peripheral.getString(KEY_PLUGIN_VERSION_STR);
       int storedCount = peripheral.getInt(KEY_PERIPHERAL_STORED_DATA_COUNT_INT);
       String peripheralType = peripheral.getString(KEY_PERIPHERAL_TYPE_STR);
       String pluginPackageName = peripheral.getString(KEY_PLUGIN_PACKAGE_NAME_STR);
       String pluginServiceName = peripheral.getString(KEY_PLUGIN_SERVICE_NAME_STR);

       // symbology is matched with PeripheralBarcodeConstants.Symbology
       ArrayList enabledSymbologyList =
               peripheral.getStringArrayList(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_LIST);
       ArrayList supportedSymbologyList =
               peripheral.getStringArrayList(KEY_PERIPHERAL_BARCODE_SUPPORTED_SYMBOLOGY_LIST);
   }
 }
 

 PeripheralManager.getInstance(context).getConnectionProfile(peripheralId,
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'getConnectionProfile' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'getConnectionProfile' function failed
         }
 });
 

 PeripheralManager.getInstance(context).getInformation(
     new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'getInformation' function succeeds
             PeripheralHelperInfo info = new PeripheralHelperInfo(bundle);
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'getInformation' function failed
         }
 });

 public class PeripheralHelperInfo {
   List mPluginList = new ArrayList<>();

   public PeripheralHelperInfo(Bundle bundle) {
     ArrayList pluginList = bundle.getParcelableArrayList(KEY_PLUGIN_BUNDLE_LIST);
     if (pluginList != null) {
         for (Bundle pluginBundle : pluginList) {
             mPluginList.add(new Plugin(pluginBundle));
         }
     }
   }

   public static class Plugin {
     String mName;
     String mVendor;
     String mVersion;
     String mPackageName;
     String mServiceName;
     List mPeripheralList = new ArrayList<>();

     public Plugin(Bundle bundle) {
         mName = bundle.getString(KEY_PLUGIN_NAME_STR);
         mVendor = bundle.getString(KEY_PLUGIN_VENDOR_STR);
         mVersion = bundle.getString(KEY_PLUGIN_VERSION_STR);
         mPackageName = bundle.getString(KEY_PLUGIN_PACKAGE_NAME_STR);
         mServiceName = bundle.getString(KEY_PLUGIN_SERVICE_NAME_STR);
         ArrayList bundleList = bundle.getParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST);
         if (bundleList != null) {
             for (Bundle peripheralBundle : bundleList) {
                 mPeripheralList.add(new Peripheral(peripheralBundle));
             }
         }
     }
   }
   public static class Peripheral {
     String mName;
     String mModelName;
     String mManufacturer;
     String mState;
     String mPeripheralType;
     String mCurrentConnectivityType;
     String mCurrentConnectivityVersion;
     String mConnectionState;
     String mBatteryLevel;
     int mUsageCount;
     String mSerialNumber;
     String mFirmware;
     String mDisconnectedReason;
     List mConnectivityList = new ArrayList<>();

     public Peripheral(Bundle bundle) {
         mName = bundle.getString(KEY_PERIPHERAL_NAME_STR);
         mModelName = bundle.getString(KEY_PERIPHERAL_MODEL_NAME_STR);
         mManufacturer = bundle.getString(KEY_PERIPHERAL_MANUFACTURER_STR);
         mState = bundle.getString(KEY_PERIPHERAL_STATE_STR);
         mPeripheralType = bundle.getString(KEY_PERIPHERAL_TYPE_STR);
         mCurrentConnectivityType = bundle.getString(KEY_RESULT_CURRENT_CONNECTIVITY_TYPE_STR);
         mCurrentConnectivityVersion = bundle.getString(KEY_RESULT_CURRENT_CONNECTIVITY_VERSION_STR);
         mConnectionState = bundle.getString(KEY_PERIPHERAL_CONNECTION_STATE_STR);
         mBatteryLevel = bundle.getString(KEY_PERIPHERAL_BATTERY_LEVEL_STR);
         mUsageCount = bundle.getInt(KEY_PERIPHERAL_USAGE_COUNT_INT, -1);
         mSerialNumber = bundle.getString(KEY_PERIPHERAL_SERIAL_NUMBER_STR);
         mFirmware = bundle.getString(KEY_PERIPHERAL_FIRMWARE_STR);
         mDisconnectedReason = bundle.getString(KEY_PERIPHERAL_DISCONNECTED_REASON_STR);
         ArrayList bundleList = bundle.getParcelableArrayList(KEY_PERIPHERAL_CONNECTIVITY_BUNDLE_LIST);
         if (bundleList != null) {
             for (Bundle connectivityBundle : bundleList) {
                 mConnectivityList.add(new Connectivity(connectivityBundle));
             }
         }
    }

   public static class Connectivity {
     String mConnectivityType;
     String mBarcodeDataProcessMode;
     List mEnabledSymbologyList = new ArrayList<>();

     public Connectivity(Bundle bundle) {
         mConnectivityType = bundle.getString(KEY_PERIPHERAL_CONNECTIVITY_TYPE_STR);
         mBarcodeDataProcessMode = bundle.getString(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR);
         mEnabledSymbologyList = bundle.getStringArrayList(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_LIST);
     }
   }
 }
 

 mPeripheralManager.getPairingBarcodeData(peripheralId,
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'getPairingBarcodeData' function succeeds
             String barcode = bundle.getString(PeripheralConstants.KEY_RESULT_BARCODE_DATA_STR);
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'getPairingBarcodeData' function failed
         }
 });
 

 PeripheralManager.getInstance(context).getStoredData(peripheralId,
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'getStoredData' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'getStoredData' function failed
         }
 });
 

 public void getSupportedPeripherals(Context context) {
     PeripheralManager peripheralManager = PeripheralManager.getInstance(context);
     peripheralManager.getSupportedPeripherals(new PeripheralResultListener() {
         public void onSuccess(Bundle bundle) {
             getPeripheralList(bundle);
         }
         public void onFail(int errorCode, String description) {
             // invoked if fail to call getSupportedPeripherals.
         }
     });
 }
 private List getPeripheralList(Bundle bundle) {
     ArrayList pluginList = new ArrayList<>();
     ArrayList pluginBundleList = bundle.getParcelableArrayList(KEY_PLUGIN_BUNDLE_LIST);

     if (pluginBundleList == null) return pluginList;
     for (Bundle plugin : pluginBundleList) {
         ArrayList peripherals =
                 plugin.getParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST);
         if (peripherals == null) continue;
         for (Bundle peripheral : peripherals) {
             String peripheralId = peripheral.getString(KEY_PERIPHERAL_ID_STR);
             pluginList.add(peripheralId);
         }
     }
     return pluginList;
 }
 

 PeripheralManager.getInstance(context).registerDataListener(
     new PeripheralDataListener() {
         public void onSuccess() {
             // invoked when 'registerDataListener' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'registerDataListener' function failed
         }
         public void onReceive(int eventType, Bundle data) {
             PeripheralHelperData barcodeData = new PeripheralHelperData(data);
         }
 });
 public class PeripheralHelperData {
     String mPeripheralId;
     String mName;
     String mModel;
     String mSerialNumber;
     String mDataType;
     List mBarcodeDataList = new ArrayList<>();

     public PeripheralHelperData(Bundle bundle) {
         mPeripheralId = bundle.getString(KEY_PERIPHERAL_ID_STR);
         mName = bundle.getString(KEY_PERIPHERAL_NAME_STR);
         mModel = bundle.getString(KEY_PERIPHERAL_MODEL_NAME_STR);
         mSerialNumber = bundle.getString(KEY_PERIPHERAL_SERIAL_NUMBER_STR);
         mDataType = bundle.getString(KEY_RESULT_DATA_TYPE_STR);
         List bundleList = bundle.getParcelableArrayList(KEY_RESULT_BARCODE_DATA_LIST);
         if (bundleList != null) {
             for (Bundle barcodeBundle : bundleList) {
                 mBarcodeDataList.add(new BarcodeData(barcodeBundle));
             }
         }
     }

     public static class BarcodeData {
         String mBarcodeData;
         String mSymbology;
         long mTimeStamp;
         String mDataProcessMode;
         String mFailReason;
         String mBarcodeRawData;

         public BarcodeData(Bundle bundle) {
             mBarcodeData = bundle.getString(KEY_RESULT_BARCODE_DATA_STR);
             mSymbology = bundle.getString(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_STR);
             mTimeStamp = bundle.getLong(KEY_PERIPHERAL_TIMESTAMP_LONG);
             mDataProcessMode = bundle.getString(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR);
             mFailReason = bundle.getString(KEY_PERIPHERAL_FAIL_REASON_STR);
             mBarcodeRawData = bundle.getString(KEY_RESULT_BARCODE_RAW_DATA_STR);
         }
     }
 }
 

 PeripheralManager.getInstance(context).registerInfoListener(
     new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'registerInfoListener' function succeeds
             // same bundle data is retrieved getInformation(PeripheralResultListener)
             PeripheralHelperInfo info = new PeripheralHelperInfo(bundle);
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'registerInfoListener' function failed
         }
 });
 

 PeripheralManager.getInstance(context).registerStateListener(
     new PeripheralStateListener() {
         public void onSuccess() {
             // invoked when 'registerStateListener' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'registerStateListener' function failed
         }
         public void onStateChange(final int eventType, final Bundle bundle) {
            // invoked when receiving state event
            if (eventType == PeripheralConstants.EventType.CONNECTION_CHANGED) {
                PeripheralHelperConnectionState state = new PeripheralHelperConnectionState(bundle);
            } else if (eventType == PeripheralConstants.EventType.ERROR_RECEIVED) {
                PeripheralHelperErrorState state = new PeripheralHelperErrorState(bundle);
            }
         }
 });

 public class PeripheralHelperConnectionState {
     List mPeripheralList = new ArrayList<>();

     public PeripheralHelperConnectionState(Bundle bundle) {
         ArrayList bundleList = bundle.getParcelableArrayList(KEY_PERIPHERAL_BUNDLE_LIST);
         if (bundleList != null) {
             for (Bundle peripheralBundle : bundleList) {
                 mPeripheralList.add(new Peripheral(peripheralBundle));
             }
         }
     }

     public static class Peripheral {
         String mId;
         String mName;
         String mModel;
         String mSerialNumber;
         String mPeripheralType;
         String mConnectionState;
         String mCurrentConnectivityType;
         String mCurrentConnectivityVersion;

         public Peripheral(Bundle bundle) {
             mId = bundle.getString(KEY_PERIPHERAL_ID_STR);
             mName = bundle.getString(KEY_PERIPHERAL_NAME_STR);
             mModel = bundle.getString(KEY_PERIPHERAL_MODEL_NAME_STR);
             mSerialNumber = bundle.getString(KEY_PERIPHERAL_SERIAL_NUMBER_STR);
             mPeripheralType = bundle.getString(KEY_PERIPHERAL_TYPE_STR);
             mConnectionState = bundle.getString(KEY_PERIPHERAL_CONNECTION_STATE_STR);
             mCurrentConnectivityType = bundle.getString(KEY_RESULT_CURRENT_CONNECTIVITY_TYPE_STR);
             mCurrentConnectivityVersion = bundle.getString(KEY_RESULT_CURRENT_CONNECTIVITY_VERSION_STR);
         }
     }
 }
 public class PeripheralHelperErrorState implements PeripheralHelperState {
     int mErrorCode;
     List mPluginList= new ArrayList<>();

     public PeripheralHelperErrorState(Bundle bundle) {
         mErrorCode = bundle.getInt(KEY_RESULT_ERROR_CODE_INT);
         if (mErrorCode == ERROR_PLUGIN_NOT_FOUND) {
             mPluginList = bundle.getStringArrayList(KEY_RESULT_PLUGIN_PACKAGE_NAME_LIST);
         }
     }
 }
 

 PeripheralManager.getInstance(context).resetPeripheral(peripheralId, resetOption
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'resetPeripheral' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'resetPeripheral' function failed
         }
 });
 

 public void setConfiguration(Context context, String peripheralId) {
   Bundle bundle = new Bundle();
   bundle.putString(KEY_PERIPHERAL_BARCODE_DATA_PROCESS_MODE_STR,
           PeripheralConstants.BarcodeDataProcessMode.WEDGE);
   bundle.putString(KEY_PERIPHERAL_PREFIX_STR, "test_prefix");
   bundle.putString(KEY_PERIPHERAL_SUFFIX_STR, "test_suffix");
   bundle.putBoolean(KEY_PERIPHERAL_BARCODE_ENABLE_TIMESTAMP_BOOL, true);
   bundle.putBoolean(KEY_PERIPHERAL_ENABLE_BEEP_SOUND_BOOL, true);
   // symbology list
   ArrayList symbolList = new ArrayList<>();
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODABAR);
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODE11);
   symbolList.add(PeripheralBarcodeConstants.Symbology.CODE32);
   symbolList.add(PeripheralBarcodeConstants.Symbology.EAN13);
   bundle.putStringArrayList(KEY_PERIPHERAL_BARCODE_ENABLED_SYMBOLOGY_LIST, symbolList);
   PeripheralManager peripheralManager = PeripheralManager.getInstance(context);

   PeripheralManager.getInstance(context).
       setConfiguration(peripheralId, bundle,
           new PeripheralResultListener(){
               public void onSuccess(Bundle bundle) {
                   // success
               }
               public void onFail(int errorCode, String description) {
                   // invoked if fail to call setConfiguration.
               }
           });
 }
 

 PeripheralManager.getInstance(context).setConnectionProfile(peripheralId, mode
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'setConnectionProfile' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'setConnectionProfile' function failed
         }
 });
 

 PeripheralManager.getInstance(context).start(profile,
     new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'start' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'start' function failed
         }
 });

 // broadcastReceiver. register this receiver with intentFilter(PeripheralConstants.ACTION_SERVICE_START)
 .... new BroadcastReceiver() {
     public void onReceive(Context context, Intent intent) {
         if (intent.getAction().equals(PeripheralConstants.ACTION_SERVICE_START)) {
             int errorCode = intent.getIntExtra(PeripheralConstants.EXTRA_SERVICE_START_RESULT, PeripheralConstants.ErrorCode.ERROR_FRAMEWORK_UNKNOWN);
             String desc = intent.getStringExtra(PeripheralConstants.EXTRA_SERVICE_START_DESCRIPTION);
             if (errorCode == PeripheralConstants.ErrorCode.ERROR_NONE) {
                  // profile is valid
             } else {
                  // profile it not valid
                 Log.e(TAG, "profile is invalid : " + desc);
             }
         }
     }
 }
 

 PeripheralManager.getInstance(context).startAutoTriggerMode(peripheralId, clearOption
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'startAutoTriggerMode' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'startAutoTriggerMode' function failed
         }
 });
 

 PeripheralManager.getInstance(context).startBarcodeScan(peripheralId,
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'startBarcodeScan' function succeeds
             // this function doesn't retrieve barcode data
             // barcode data is notified by PeripheralDataListener
             // please find registerDataListener(PeripheralDataListener)
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'startBarcodeScan' function failed
         }
 });

 PeripheralManager.getInstance(context).stop(
     new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'stop' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'stop' function failed
         }
 });
 

 PeripheralManager.getInstance(context).stopAutoTriggerMode(peripheralId, clearOption
    new PeripheralResultListener() {
         public void onSuccess(Bundle data) {
             // invoked when 'stopAutoTriggerMode' function succeeds
         }
         public void onFail(int errorCode, String description) {
             // invoked when 'stopAutoTriggerMode' function failed
         }
 });
 

 mPeripheralManager.stopPairingPeripheral(
    new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'stopPairingPeripheral' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'stopPairingPeripheral' function failed
         }
 });
 

 Bundle option = new Bundle(); // optional
 option.putInt(PeripheralConstants.VibrationEffect.INTERVAL_INT, 500); // optional
 option.putInt(PeripheralConstants.VibrationEffect.REPEAT_INT, 3); // optional
 // option is 'repeat 3 times, interval is 500 milliseconds

 PeripheralManager.getInstance(context).vibrate(mPeripheralId, milliseconds, option,
     new PeripheralResultListener() {

         public void onSuccess(Bundle data) {
             // invoked when 'vibrate' function succeeds
         }

         public void onFail(int errorCode, String description) {
             // invoked when 'vibrate' function failed
         }
 });