radiobuttonPanel.setBounds(20, 100, 400, 50);
		radioButtonsGroup = new ButtonGroup();
		realMeasurementButton = createJRadioButton("Real measurement");
		realMeasurementButton.setToolTipText("Continua devices should be paired first");
		simulatedMeasurementButton = createJRadioButton("Simulated measurement");
		simulatedMeasurementButton
				.setToolTipText("Random values will be published to universAAL context bus (Continua devices not required)");
		radiobuttonPanel.add(realMeasurementButton);
		radiobuttonPanel.add(simulatedMeasurementButton);
		mainPanel.add(radiobuttonPanel);
		// Buttons
		bloodPressureButton = createJButton(bloodPressureImage, 214, 160, 218, 145, "bloodPressure");
		mainPanel.add(bloodPressureButton);
		weighingScaleButton = createJButton(weighingScaleImage, 18, 154, 178, 157, "weighingScale");
		mainPanel.add(weighingScaleButton);
	}

	/** Create JPanel */
	public JPanel createJPanel() {
		JPanel output = null;
		output = new JPanel();
		output.setLayout(null);
		output.setBorder(new EmptyBorder(5, 5, 5, 5));
		output.setBackground(Color.WHITE);
		return output;
	}

	/** Create JButtons */
	public JButton createJButton(String image, int x, int y, int weight, int height, String name) {
		JButton output = null;
		output = new JButton("");
		output.setBackground(Color.WHITE);
		if (image != null)
			output.setIcon(new ImageIcon(ctx.getBundle().getResource(image)));
		output.setBounds(x, y, weight, height);
		output.setActionCommand(name);
		output.addActionListener(this);
		return output;
	}

	/** Create JRadioButtons */
	public JRadioButton createJRadioButton(String name) {
		JRadioButton output = null;
		output = new JRadioButton(name, false);
		output.setActionCommand(name);
		output.setBackground(Color.WHITE);
		output.addActionListener(this);
		radioButtonsGroup.add(output);
		return output;
	}

	/** Close GUI frame */
	public void closeGUI() {
		dispose();
	}

	/** Action listener for radio buttons and jbuttons */
	public void actionPerformed(ActionEvent e) {
		if (e.getActionCommand().equals("bloodPressure")) {
			// Blood pressure device
			if (realMeasurementButton.isSelected()) {
				realMeasurement = true;
				createPublisher("bloodPressure", "real");
			} else if (simulatedMeasurementButton.isSelected()) {
				realMeasurement = false;
				createPublisher("bloodPressure", "simulated");
			}
		} else if (e.getActionCommand().equals("weighingScale")) {
			// Weighing scale device
			if (realMeasurementButton.isSelected()) {
				realMeasurement = true;
				createPublisher("weighingScale", "real");
			} else if (simulatedMeasurementButton.isSelected()) {
				realMeasurement = false;
				createPublisher("weighingScale", "simulated");
			}
		} else if (e.getActionCommand().equals("publishData")) {
			// Publish data to universAAL context bus. Ensure that values are not NULL
			X73Publisher = new Publisher(ctx);
			if (realMeasurement) {
				// Real values
				if (remoteDeviceType.equals("WeightingScale")) {
					if (finalMeasuredWeightData != -1.0) {
						double temp_1 = shortDecimalNumber(finalMeasuredWeightData) * 1000;
						int temp = (int) temp_1;
						X73Publisher.publishWeightEvent(temp);
						// stopPublisherGUI();
					}
				} else {
					if ((finalDiaBloodPressureData != -1) && (finalHrBloodPressureData != -1)
							&& (finalSysBloodPressureData != -1)) {
						int temp_0 = (int) finalSysBloodPressureData;
						int temp_1 = (int) finalDiaBloodPressureData;
						int temp_2 = (int) finalHrBloodPressureData;
						X73Publisher.publishBloodPressureEvent(temp_0, temp_1, temp_2);
						// stopPublisherGUI();
					}
				}
			} else {
				// Random values
				if (remoteDeviceType.equals("WeightingScale")) {
					X73Publisher.publishWeightEvent(Integer.parseInt(publisherWeightValueTextfield.getText()));
					// stopPublisherGUI();
				} else {
					X73Publisher.publishBloodPressureEvent(
							Integer.parseInt(publisherBloodPressureSysValueTextfield.getText()),
							Integer.parseInt(publisherBloodPressureDiaValueTextfield.getText()),
							Integer.parseInt(publisherBloodPressurePulValueTextfield.getText()));
					// stopPublisherGUI();
				}
			}
		}
	}

	/** Create and show universAAL publisher frame */
	public void createPublisher(String device, String type) {
		// Hide main GUI
		setVisible(false);
		// Create dialog frame
		publisher = new JDialog(this, "universAAL publisher", true);
		publisher.setResizable(false);
		publisher.setBounds(100, 100, 650, 325);

				stopPublisherGUI();
			}
		});
		// Main panel
		mainPublisherPanel = createJPanel();
		publisher.getContentPane().add(mainPublisherPanel, BorderLayout.CENTER);
		// Main text label
		publisherMainLabel = createJLabel("", 200, 5, 350, 50, Font.BOLD, 24);
		// Image icon
		publisherLogoLabel = new JLabel("");
		publisherLogoLabel.setBounds(25, 75, 218, 145);
		// Check Continua agent selected
		if (device.equals("bloodPressure")) {
			publisherMainLabel.setText("Blood pressure monitor");
			publisherLogoLabel.setIcon(new ImageIcon(ctx.getBundle().getResource(bloodPressureImage)));
			publisherBloodPressureSysValueLabel = createJLabel("SYS(mmHg)", 250, 100, 100, 50, Font.PLAIN, 16);
			publisherBloodPressureSysValueTextfield = createJTextfield(400, 100, 100, 50, Font.PLAIN, 16);
			publisherBloodPressureDiaValueLabel = createJLabel("DIA(mmHg)", 250, 150, 100, 50, Font.PLAIN, 16);
			publisherBloodPressureDiaValueTextfield = createJTextfield(400, 150, 100, 50, Font.PLAIN, 16);
			publisherBloodPressurePulValueLabel = createJLabel("     BPM", 250, 200, 100, 50, Font.PLAIN, 16);
			publisherBloodPressurePulValueTextfield = createJTextfield(400, 200, 100, 50, Font.PLAIN, 16);
		} else {
			publisherMainLabel.setText("Weighing scale");
			publisherLogoLabel.setIcon(new ImageIcon(ctx.getBundle().getResource(weighingScaleImage)));
			publisherWeightValueLabel = createJLabel("Weight value", 250, 100, 150, 50, Font.PLAIN, 16);
			publisherWeightValueTextfield = createJTextfield(400, 100, 100, 50, Font.PLAIN, 16);
			publisherWeightUnitLabel = createJLabel(" Weight unit", 250, 150, 150, 50, Font.PLAIN, 16);
			publisherWeightUnitTextfield = createJTextfield(400, 150, 100, 50, Font.PLAIN, 16);
		}
		publisherButton = createJButton(null, 250, 275, 200, 25, "publishData");
		publisherButton.setText("Publish to universAAL");
		publisherButton.setToolTipText("Public measured data to universAAL context bus");
		// Check type of measurement
		if (type.equals("real")) {
			// Run hdp manager and wait for agent values
			if (device.equals("bloodPressure")) {
				remoteDeviceType = "BloodPressureMonitor";
				instantiateHdpManager();
			} else {
				remoteDeviceType = "WeightingScale";
				instantiateHdpManager();
			}
		} else {
			// Generate random values
			if (device.equals("bloodPressure")) {
				remoteDeviceType = "BloodPressureMonitor";
				publisherBloodPressureSysValueTextfield.setText("" + getRandomValue(90, 119));
				publisherBloodPressureDiaValueTextfield.setText("" + getRandomValue(60, 79));
				publisherBloodPressurePulValueTextfield.setText("" + getRandomValue(49, 198));
			} else {
				remoteDeviceType = "WeightingScale";
				publisherWeightValueTextfield.setText("" + getRandomValue(50, 110));
				publisherWeightUnitTextfield.setText("kg");
			}
		}
		// Add components to the panel
		mainPublisherPanel.add(publisherMainLabel);
		mainPublisherPanel.add(publisherLogoLabel);
		addJLabelComponent(publisherBloodPressureSysValueLabel);
		addJLabelComponent(publisherBloodPressureSysValueTextfield);
		addJLabelComponent(publisherBloodPressureDiaValueLabel);
		addJLabelComponent(publisherBloodPressureDiaValueTextfield);
		addJLabelComponent(publisherBloodPressurePulValueLabel);
		addJLabelComponent(publisherBloodPressurePulValueTextfield);
		addJLabelComponent(publisherWeightValueLabel);
		addJLabelComponent(publisherWeightValueTextfield);
		addJLabelComponent(publisherWeightUnitLabel);
		addJLabelComponent(publisherWeightUnitTextfield);
		mainPublisherPanel.add(publisherButton);
		// Show
		publisher.setVisible(true);

	}

	/** Java methods */
	// Init method
	public void init() {
		// Create the objects related to ISO/IEEE 11073 Manager interpreter
		eventmanager = new EventIEEEManager();
		x73manager = new Manager(eventmanager);
		fsm = x73manager.getFSM();
		rmp = x73manager.getMessageProcessor();
		// First (mandatory) step: DBUS platform should be successfully
		// initialized (otherwise JVM will return fatal errors)
		if (startDbusPlatform()) {
			// Get and show the object path of the DEFAULT adapter (in GNU/Linux
			// environments should be 'hci0')
			String defaultDevicePathTemp = getLocalBluetoothAdapterPath();
			System.out.println("Default bluetooth adapter path: " + defaultDevicePathTemp);
			if (defaultDevicePathTemp == null) {
				System.out.println("Unable to detect bluetooth adapters");
				System.exit(0);
			}
			// Show the object path of ALL the local bluetooth adapters
			// available at our PC
			System.out.println("List of local bluetooth adapters:");
			showLocalBluetoothAdaptersPath();
			// Show some properties of the DEFAULT adapter: address, name,
			// class, powered, discoverable, pairable, discoverable timeout,
			// pairable timeout,
			// discovering, devices and UUIDs. Check bluetooth manuals to
			// understand the meaning of each
			System.out.println("Local bluetooth properties:");
			showDefaultLocalBluetoothAdaptersProperties();
			// Object path of a remote device
			remoteDevicePath = getRemoteBluetoothAdapterPath(macAddressRemoteDevice);
			System.out.println("Remote bluetooth adapter path: " + remoteDevicePath);
			// Remote device properties (from its own path)
			System.out.println("Remote device properties (BEFORE):");
			showRemoteBluetoothAdapterProperties(remoteDevicePath);
			// Prior to start any communication process, we need to ensure that
			// the remote device appears as a 'Trusted' (true value) device (by
			// default
			// it should appear as false (not trusted) so we need to change this
			// property
			setPropertyRemoteDevice(remoteDevicePath, trustedProperty, true);
			// Show the properties of the remote device to verify that the
			// 'Trusted' value has been successfully changed (false -> true)
			System.out.println("Remote device properties (AFTER):");
			showRemoteBluetoothAdapterProperties(remoteDevicePath);
			// We need to create an HDP application before any HDP data frames
			// exchange between agents/sources and managers/sinks. IMPORTANT:
			// the app
			// created will be only valid for the data types and roles passed as
			// arguments. For instance, this HDP channel will be created only if
			// the
			// remote device is a weight scale acting as a source. So, here we
			// go...
			String hdpApplicationIdTemp = createHDPApplication(dataTypeValue, roleValue, shortDescriptionValue,
					channelTypeValue);
			System.out.println("HDP application identifier: " + hdpApplicationIdTemp);
			// HDP app successfully created
			if (hdpApplicationIdTemp != null) {
				// We have the option to destroy/close any HDP application. For
				// security reason, only the owner of this process will be able
				// to destroy it
				destroyHDPApplication(hdpApplicationIdTemp);
				// New HDP application (again)
				hdpApplicationIdTemp = createHDPApplication(dataTypeValue, roleValue, shortDescriptionValue,
						channelTypeValue);
				System.out.println("HDP application identifier: " + hdpApplicationIdTemp);
				// A good practice should be check the availability of the DBUS
				// system (is it still alive?)
				System.out.println("DBUS sytem status: " + (getDbusSystemAvailability() ? "Up" : "Down"));
				// Remember that those PHD devices with compatible data type and
				// role (weight scales and sources) are able to find our
				// applicattion through
				// bluetooth connections. At this case: we are a sink so we need
				// to wait for input connections (handle signals). First step:
				// we need to
				// subscribe our application to HDP events in the DBUS system.
				if (!enableHDPListener()) {
					System.out.println("Unable to listen HDP messages inside DBUS");
					System.exit(0);
				} else {
					System.out.println(fsm.getStringTransportState() + " " + fsm.getStringChannelState());
					waitHDPConnections();
				}
			}
		} else {
			System.out.println(
					"Ups. Bad news, the monkey who has developed this application ran out of nuts. Try again later...");
		}
	}

	/* HDP channel available. x073 state machine at connected status */
	public void onChannelConnected() {
		// Get the object path of the just created HDP channel
		if (remoteDevicePath != null) {
			hdpDataChannelPath = getHDPDataChannelPath(remoteDevicePath);
			System.out.println("HDP channel path: " + hdpDataChannelPath);

public class Publisher {

	// Atributes
	// Default context publisher
	private ContextPublisher cp;
	// Context provider info (provider type)
	ContextProvider cpInfo = new ContextProvider();
	// Module context
	ModuleContext mc;
	// URI prefix
	public static final String PUBLISHER_URI_PREFIX = "http://http://ontology.universAAL.org/PersonalHealtDeviceSimulator.owl#";

	// Constructor

	/**
	 * Publisher contructor
	 *
	 * @param context
	 *            - framework bundle context
	 */
	public Publisher(BundleContext context) {
		// Instantiate the context provider info with a valid provider URI
		cpInfo = new ContextProvider(PUBLISHER_URI_PREFIX + "PersonalHealthDeviceContextProvider");
		mc = OSGiContainer.THE_CONTAINER.registerModule(new Object[] { context });
		// Set to type gauge (only publishes data information it senses)
		cpInfo.setType(ContextProviderType.gauge);
		// Set the provided events to unknown with an empty pattern
		cpInfo.setProvidedEvents(new ContextEventPattern[] { new ContextEventPattern() });
		// Create and register the context publisher
		cp = new DefaultContextPublisher(mc, cpInfo);
	}

	// Methods

	/** Publish weighting scale events to universAAL bus */
	public void publishWeightEvent(int weight) {
		WeighingScale ws = new WeighingScale(PUBLISHER_URI_PREFIX + "WeighingScale");
		PersonWeight m_ws = new PersonWeight(PUBLISHER_URI_PREFIX + "Measurement_Weight");
		m_ws.setProperty(Measurement.PROP_VALUE, Float.valueOf((float) weight));
		ws.setValue(m_ws);
		cp.publish(new ContextEvent(ws, WeighingScale.PROP_HAS_VALUE));
	}

	/** Publish blood pressure events to universAAL bus */
	public void publishBloodPressureEvent(int sys, int dia, int hr) {
		BloodPressure value = new BloodPressure(PUBLISHER_URI_PREFIX + "BloodPressureMeasurement");

		Measurement systolic = new Measurement();
		systolic.setValue(Float.valueOf(sys));

		Measurement diastolic = new Measurement();
		diastolic.setValue(Float.valueOf(dia));

		value.setSyst(systolic);
		value.setDias(diastolic);

		BloodPressureSensor sensor = new BloodPressureSensor(PUBLISHER_URI_PREFIX + "continuaBTBloodPressureSensor");
		sensor.setValue(value);

		cp.publish(new ContextEvent(sensor, BloodPressureSensor.PROP_HAS_VALUE));

		HeartRate hrvalue = new HeartRate();
		hrvalue.setProperty(Measurement.PROP_VALUE, Integer.valueOf(hr));
		HeartRateSensor hrsensor = new HeartRateSensor(PUBLISHER_URI_PREFIX + "continuaBTHeartRateSensor");
		hrsensor.setValue(hrvalue);

		cp.publish(new ContextEvent(hrsensor, BloodPressureSensor.PROP_HAS_VALUE));
	}
}

public class MyLightingOntologified {
	/**
	 * Real implementation controlling light sources.
	 */
	private MyLighting realLighting = new MyLighting();

	public MyLightingOntologified(String namespace) {
		/* Initializing fields with ontological constants */
		this.LAMP_URI_PREFIX = namespace + "controlledLamp";
		this.LOCATION_URI_PREFIX = "urn:space:myHome#";
	}

	/*
	 * Fields and methods for mapping real implementation onto ontology.
	 */

	private final String LAMP_URI_PREFIX;
	private final String LOCATION_URI_PREFIX;

	private String constructLampURIfromLocalID(int localID) {
		return LAMP_URI_PREFIX + localID;
	}

	private String constructLocationURIfromLocalID(String localID) {
		return LOCATION_URI_PREFIX + localID;
	}

	private int extractLocalIDfromLampURI(String lampURI) {
		return Integer.parseInt(lampURI.substring(LAMP_URI_PREFIX.length()));
	}

	/*
	 * Implementation of ontological interface
	 */

	public LightSource[] getControlledLamps() {
		ArrayList<LightSource> al = new ArrayList<LightSource>();
		Integer[] controlledLamps = realLighting.getControlledLamps();
		for (int i = 0; i < controlledLamps.length; i++) {
			LightSource ls = new LightSource(constructLampURIfromLocalID(i));
			ls.setLightType(ElectricLight.lightBulb);
			al.add(ls);
		}
		return al.toArray(new LightSource[0]);
	}

	public Object[] getLampInfo(LightSource lamp) {
		int lampID = extractLocalIDfromLampURI(lamp.getURI());
		int state = realLighting.getState(lampID);
		String loc = realLighting.getLampLocation(lampID);
		Room ontologyLoc = new Room(constructLocationURIfromLocalID(loc));
		return new Object[] { state, ontologyLoc };
	}

	public void turnOff(LightSource lamp) {
		int lampID = extractLocalIDfromLampURI(lamp.getURI());
		realLighting.turnOff(lampID);
	}

	public void turnOn(LightSource lamp) {
		int lampID = extractLocalIDfromLampURI(lamp.getURI());
		realLighting.turnOn(lampID);
	}
}

public class MyLighting {
	private class Lamp {
		String loc;
		boolean isOn;

		Lamp(String loc, boolean isOn) {
			this.loc = loc;
			this.isOn = isOn;
		}
	}

	private Lamp[] myLampDB = new Lamp[] { new Lamp("loc1", false), new Lamp("loc2", false), new Lamp("loc3", false),
			new Lamp("loc4", false) };

	public String getLampLocation(int lampID) {
		return myLampDB[lampID].loc;
	}

	public int getState(int lampID) {
		return myLampDB[lampID].isOn ? 100 : 0;
	}

	public Integer[] getControlledLamps() {
		Integer[] ids = new Integer[myLampDB.length];
		for (int i = 0; i < myLampDB.length; i++)
			ids[i] = i;
		return ids;
	}

	public Object[] getLampInfo(int lampID) {
		String loc = getLampLocation(lampID);
		int state = getState(lampID);
		return new Object[] { state, loc };
	}

	public void turnOff(int lampID) {
		if (myLampDB[lampID].isOn) {
			myLampDB[lampID].isOn = false;
		}
	}

	public void turnOn(int lampID) {
		if (!myLampDB[lampID].isOn) {
			myLampDB[lampID].isOn = true;
		}
	}
}

		publisher.setVisible(true);
	}

	/** Create JLabel */
	public JLabel createJLabel(String name, int x, int y, int weight, int height, int fontType, int fontSize) {
		JLabel output = null;
		output = new JLabel(name);
		output.setBounds(x, y, weight, height);
		output.setFont(new Font("Courier", fontType, fontSize));
		output.setHorizontalTextPosition(SwingConstants.CENTER);
		return output;
	}

	/** Create JTextfield */
	public JTextField createJTextfield(int x, int y, int weight, int height, int fontType, int fontSize) {
		JTextField output = null;
		output = new JTextField(10);
		output.setBounds(x, y, weight, height);
		output.setEditable(false);
		output.setColumns(10);
		output.setHorizontalAlignment(JTextField.CENTER);
		output.setFont(new Font("Courier", fontType, fontSize));
		return output;
	}

	/** Add components to panel */
	public void addJLabelComponent(JComponent component) {
		if (component != null)
			mainPublisherPanel.add(component);
	}

	/** Reset components */
	public void resetComponentsStatus() {
		publisherWeightValueLabel = null;
		publisherWeightValueTextfield = null;
		publisherWeightUnitLabel = null;
		publisherWeightUnitTextfield = null;
		publisherBloodPressureSysValueLabel = null;
		publisherBloodPressureSysValueTextfield = null;
		publisherBloodPressureDiaValueLabel = null;
		publisherBloodPressureDiaValueTextfield = null;
		publisherBloodPressurePulValueLabel = null;
		publisherBloodPressurePulValueTextfield = null;
		remoteDeviceType = null;
		realMeasurement = false;
		finalMeasuredWeightData = -1.0;
		finalSysBloodPressureData = -1;
		finalDiaBloodPressureData = -1;
		finalHrBloodPressureData = -1;
	}

	/** Shorten number of decimals */
	public double shortDecimalNumber(double d) {

		ServiceResponse response = caller.call(getGetEventsRequest(matchEvent, tstFrom, tstTo));
		if (response.getCallStatus() == CallStatus.succeeded) {
			// Object value = getReturnValue(response.getOutputs(),
			// OUTPUT_LIST_OF_EVENTS);
			Object value = response.getOutput(OUTPUT_LIST_OF_EVENTS, true);
			if (value instanceof Resource) {
				if (((Resource) value).getURI().contains("#nil")) {
					log.info("History Client - result is empty");
					return 0;
				}
			} else {
				try {
					ContextEvent[] events = (ContextEvent[]) ((List) value)
							.toArray(new ContextEvent[((List) value).size()]);

					for (int j = 0; j < events.length; j++) {
						count++;
						log.info("Retrieved context event from CHe:\n" + "    Subject     =" + events[j].getSubjectURI()
								+ "\n" + "    Subject type=" + events[j].getSubjectTypeURI() + "\n"
								+ "    Predicate   =" + events[j].getRDFPredicate() + "\n" + "    Object      ="
								+ events[j].getRDFObject());
						log.info(Activator.ser.serialize(events[j]));
					}
				} catch (Exception e) {
					log.info("History Client: List of events corrupt!", e);
				}
			}
		} else
			log.info("History Client - status of getEvents(): " + response.getCallStatus());
		return count;
	}

	private ServiceRequest getGetEventsRequest(org.universAAL.ontology.che.ContextEvent matchEvent, long tstFrom,

	private String remoteDeviceType = null;

	/** Native functions */

	/**
	 * Start dbus platform for message interchanging within processes in Linux
	 * OS.
	 *
	 * @return if the Dbus platform is correctly initialized.
	 */
	private native boolean startDbusPlatform();

	/**
	 * Get the path for the local Bluetooth adapter which is in use at the
	 * moment.
	 *
	 * @return local bluetooth adapter path
	 */
	private native String getLocalBluetoothAdapterPath();

	/**
	 * Show path of all local bluetooth adapters available at PC (may be more
	 * than one).
	 */
	private native void showLocalBluetoothAdaptersPath();

	/**
	 * Show all properties of the DEFAULT local bluetooth adapter. In case a
	 * computer has more than one Bluetooth adapter, there will be one in use by
	 * default.
	 */
	private native void showDefaultLocalBluetoothAdaptersProperties();

	/**
	 * Get the object path of a remote device given a MAC address
	 * (format:XX:XX:XX:XX:XX:XX).
	 *
	 * @param macAddressRemoteDevice
	 *            the MAC address of the desired remote device (the format of
	 *            the MAC is XX:XX:XX:XX:XX:XX).
	 * @return the path for the remote Bluetooth device in the local machine.
	 */
	private native String getRemoteBluetoothAdapterPath(String macAddressRemoteDevice);

	/**
	 * Show all properties of a remote device (it should be first created with
	 * getRemoteBluetoothAdapterPath method).
	 *
	 * @param remoteDevicePath
	 *            the path for the remote Bluetooth device in the local machine.
	 * @see showDefaultLocalBluetoothAdaptersProperties()
	 */
	private native void showRemoteBluetoothAdapterProperties(String remoteDevicePath);

	/**
	 * Modify a property of a remote device. This will be used for enabling the
	 * "Trusted" property in a remote Health Device Profile capable device for
	 * being establish a connection.
	 *
	 * @param remoteDevicePath
	 *            the path for the remote Bluetooth device in the local machine.
	 * @param propertyKey
	 *            the name of the property to be modified.
	 * @param propertyValue
	 *            the new value for the property.
	 */
	private native void setPropertyRemoteDevice(String remoteDevicePath, String propertyKey, boolean propertyValue);

	/**
	 * Create a new HDP application and gets the object path of the new created
	 * application.
	 *
	 * @param dataTypeValue
	 *            which kind of a HDP capable device will be used.
	 * @param roleValue
	 *            set the role of the HDP role that the local machine will be
	 *            playing. Usually, "Sink"
	 * @param shortDescriptionValue
	 *            custom string for helping the remote devices to identify the
	 *            local machine they are connected to.
	 * @param channelTypeValue
	 *            set whether the channel is working with trusted or streaming
	 *            mode.
	 * @return the path of the new Health Device Profile application newly
	 *         created in the local machine.
	 */
	private native String createHDPApplication(String dataTypeValue, String roleValue, String shortDescriptionValue,
			String channelTypeValue);

	/**
	 * Destroy an HDP application.
	 *
	 * @param objectPathHDPApplication
	 *            the path of the Health Device Profile application to be
	 *            destroyed.
	 */
	private native void destroyHDPApplication(String objectPathHDPApplication);

	/**
	 * Checks DBUS system availability.
	 *
	 * @return true if the Dbus system is available, or false if not.
	 */
	private native boolean getDbusSystemAvailability();

	/**
	 * Add a specific rule to follow HDP messages inside DBUS.
	 *
	 * @return true if the local application is subscribed to HDP messages in
	 *         DBus.
	 */
	private native boolean enableHDPListener();

	/**
	 * Wait for new incoming HDP connections.
	 */
	private native void waitHDPConnections();

	/**
	 * Get the object path of the HDP channel ready to send/receive data to/from
	 * Continua devices.
	 *
	 * @param remoteDevicePath
	 *            the path for the remote Bluetooth device in the local machine.
	 * @return the path of the data channel from a Health Device Profile
	 *         application.
	 */
	private native String getHDPDataChannelPath(String remoteDevicePath);

	/**
	 * Show the properties of a HDP data channel previously created.
	 *
	 * @param hdpDataChannelPath
	 *            the path of the data channel from a Health Device Profile
	 *            application.
	 */
	private native void showHDPDataChannelProperties(String hdpDataChannelPath);

	/**
	 * Get the file descriptor associated to a HDP data channel
	 *
	 * @param hdpDataChannelPath
	 *            the path of the data channel from a Health Device Profile
	 *            application.
	 * @return the number that identifies the file descriptor in a Linux OS.
	 */
	private native int getHDPDataChannelFileDescriptor(String hdpDataChannelPath);

	/**
	 * Release the file descriptor associated to this HDP data channel (HDP
	 * application will be closed).
	 *
	 * @param hdpDataChannelPath
	 *            the path of the data channel from a Health Device Profile
	 *            application.
	 */
	private native void releaseHDPDataChannelFileDescriptor(String hdpDataChannelPath);

	/**
	 * Wait for HDP data frames from Continua Health devices. These frames will
	 * be compliant with ISO/IEEE 11073 standard.
	 *
	 * @param hdpDataChannelFileDescriptor
	 *            the file descriptor that identifies a HDP data channel.
	 */
	private native void waitHDPDataFrames(int hdpDataChannelFileDescriptor);

	/**
	 * Get the input data frame from a Continua Health device. The data will be
	 * retrieved in raw format (byte array), and will be processed by the
	 * ISO/IEEE 11073 library included.
	 *
	 * @param hdpDataChannelFileDescriptor
	 *            the file descriptor that identifies a HDP data channel.
	 * @return the data a remote device sent, in raw format.
	 */
	private native byte[] getHDPDataFrame(int hdpDataChannelFileDescriptor);

	/**
	 * Get the number of bytes read from input data frames.
	 *
	 * @param hdpDataChannelFileDescriptor
	 *            the file descriptor that identifies a HDP data channel.
	 * @return the size of the data frame received.
	 */
	private native int getSizeHDPDataFrame(int hdpDataChannelFileDescriptor);

	/**
	 * Show HDP data frame received.
	 *
	 * @param hdpDataChannelFileDescriptor
	 *            the file descriptor that identifies a HDP data channel.
	 */
	private native void showHDPDataFrame(int hdpDataChannelFileDescriptor);

	/**
	 * Send HDP data frames to Continua Health devices after processing the ones
	 * previously received and generate the proper response to them.
	 *
	 * @param hdpDataChannelFileDescriptor
	 *            the file descriptor that identifies a HDP data channel.
	 * @param hdpDataFrame
	 *            the raw byte array of the data that will be sent back to a
	 *            Continua device.
	 */
	private native void sendHDPDataToDevice(int hdpDataChannelFileDescriptor, byte[] hdpDataFrame);

	/**
	 * Free all employed resources and end HDP manager in a well-known status
	 *
	 */
	private native void closeHDPManager();

	/** Constructor */
	public hdpManager(String str) {

		req.addSimpleOutputBinding(po, new String[] { ProfilingService.PROP_CONTROLS, Profilable.PROP_HAS_PROFILE,
				Profile.PROP_HAS_SUB_PROFILE });
		ServiceResponse resp = caller.call(req);
		if (resp.getCallStatus() == CallStatus.succeeded) {
			// Object
			// out=getReturnValue(resp.getOutputs(),OUTPUT_GETSUBPROFILES);
			Object out = resp.getOutput(OUTPUT_GETSUBPROFILES, true);
			if (out != null) {
				log.debug(out.toString());
				return out.toString();
			} else {
				log.debug("NOTHING!");
				return "nothing";
			}
		} else {
			return resp.getCallStatus().name();
		}
	}

	// :::::::::::::PROFILABLE GET/ADD/CHANGE/REMOVE:::::::::::::::::
	private String removeProfilable(Resource profilable) {