MQTT client demo builds and links - but it is still using shared objects instead of static libs

Author: jmcclin2

CMakeLists.txt

@@ -15,9 +15,18 @@ add_executable(mqtt_pi_client ${SOURCE_FILES})
 target_include_directories(mqtt_pi_client
     PUBLIC
     .
-    #include
-    #ports/posix
-    #source/
+    paho.mqtt.c/src
+    paho.mqtt.cpp/src
+)
+
+find_library(PAHO_MQTT_C_LIB_PRO NAMES paho-mqtt3as libpaho-mqtt3as HINTS "${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.c/src")
+find_library(PAHO_MQTT_CPP_LIB_PRO NAMES paho-mqttpp3 libpaho-mqttpp3 HINTS "${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.cpp/src")
+
+
+target_link_libraries(mqtt_pi_client
+    PUBLIC
+    ${PAHO_MQTT_C_LIB_PRO}
+    ${PAHO_MQTT_CPP_LIB_PRO}
 )
 
 # Build Paho MQTT C as lib to be used by Paho MQTT C++
@@ -28,11 +37,12 @@ set(PAHO_HIGH_PERFORMANCE TRUE)
 add_subdirectory(paho.mqtt.c)
 
 # Specify where the MQTT C libs/headers can be found
-#list(APPEND CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.c/src")
+list(APPEND CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.c/src")
 set(PAHO_MQTT_C_LIBRARIES ${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.c/src/libpaho-mqtt3cs.so) #TODO: Determine what lib we actually want to link to - there are three variants
 set(PAHO_MQTT_C_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/paho.mqtt.c/src)
 
 # Many of the above Paho MQTT C settings apply to C++ as well
+list(APPEND CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/paho.mqtt.cpp/src")
 add_subdirectory(paho.mqtt.cpp)
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})

main.cpp

@@ -1,10 +1,179 @@
 #include <iostream>
 #include "project_config.hpp"
 
+#include "mqtt/async_client.h"
+
 using std::cout;
 using std::endl;
 
+const std::string SERVER_ADDRESS("tcp:broker.hivemq.com:1883");
+const std::string CLIENT_ID("totally_random_guy");
+const std::string TOPIC("goofygumdrop");
+
+const int	QOS = 1;
+const int	N_RETRY_ATTEMPTS = 5;
+
+// Callbacks for the success or failures of requested actions.
+// This could be used to initiate further action, but here we just log the
+// results to the console.
+
+class action_listener : public virtual mqtt::iaction_listener
+{
+	std::string name_;
+
+	void on_failure(const mqtt::token& tok) override {
+		std::cout << name_ << " failure";
+		if (tok.get_message_id() != 0)
+			std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+		std::cout << std::endl;
+	}
+
+	void on_success(const mqtt::token& tok) override {
+		std::cout << name_ << " success";
+		if (tok.get_message_id() != 0)
+			std::cout << " for token: [" << tok.get_message_id() << "]" << std::endl;
+		auto top = tok.get_topics();
+		if (top && !top->empty())
+			std::cout << "\ttoken topic: '" << (*top)[0] << "', ..." << std::endl;
+		std::cout << std::endl;
+	}
+
+public:
+	action_listener(const std::string& name) : name_(name) {}
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Local callback & listener class for use with the client connection.
+ * This is primarily intended to receive messages, but it will also monitor
+ * the connection to the broker. If the connection is lost, it will attempt
+ * to restore the connection and re-subscribe to the topic.
+ */
+class callback : public virtual mqtt::callback,
+					public virtual mqtt::iaction_listener
+
+{
+	// Counter for the number of connection retries
+	int nretry_;
+	// The MQTT client
+	mqtt::async_client& cli_;
+	// Options to use if we need to reconnect
+	mqtt::connect_options& connOpts_;
+	// An action listener to display the result of actions.
+	action_listener subListener_;
+
+	// This deomonstrates manually reconnecting to the broker by calling
+	// connect() again. This is a possibility for an application that keeps
+	// a copy of it's original connect_options, or if the app wants to
+	// reconnect with different options.
+	// Another way this can be done manually, if using the same options, is
+	// to just call the async_client::reconnect() method.
+	void reconnect() {
+		std::this_thread::sleep_for(std::chrono::milliseconds(2500));
+		try {
+			cli_.connect(connOpts_, nullptr, *this);
+		}
+		catch (const mqtt::exception& exc) {
+			std::cerr << "Error: " << exc.what() << std::endl;
+			exit(1);
+		}
+	}
+
+	// Re-connection failure
+	void on_failure(const mqtt::token& tok) override {
+		std::cout << "Connection attempt failed" << std::endl;
+		if (++nretry_ > N_RETRY_ATTEMPTS)
+			exit(1);
+		reconnect();
+	}
+
+	// (Re)connection success
+	// Either this or connected() can be used for callbacks.
+	void on_success(const mqtt::token& tok) override {}
+
+	// (Re)connection success
+	void connected(const std::string& cause) override {
+		std::cout << "\nConnection success" << std::endl;
+		std::cout << "\nSubscribing to topic '" << TOPIC << "'\n"
+			<< "\tfor client " << CLIENT_ID
+			<< " using QoS" << QOS << "\n"
+			<< "\nPress Q<Enter> to quit\n" << std::endl;
+
+		cli_.subscribe(TOPIC, QOS, nullptr, subListener_);
+	}
+
+	// Callback for when the connection is lost.
+	// This will initiate the attempt to manually reconnect.
+	void connection_lost(const std::string& cause) override {
+		std::cout << "\nConnection lost" << std::endl;
+		if (!cause.empty())
+			std::cout << "\tcause: " << cause << std::endl;
+
+		std::cout << "Reconnecting..." << std::endl;
+		nretry_ = 0;
+		reconnect();
+	}
+
+	// Callback for when a message arrives.
+	void message_arrived(mqtt::const_message_ptr msg) override {
+		std::cout << "Message arrived" << std::endl;
+		std::cout << "\ttopic: '" << msg->get_topic() << "'" << std::endl;
+		std::cout << "\tpayload: '" << msg->to_string() << "'\n" << std::endl;
+	}
+
+	void delivery_complete(mqtt::delivery_token_ptr token) override {}
+
+public:
+	callback(mqtt::async_client& cli, mqtt::connect_options& connOpts)
+				: nretry_(0), cli_(cli), connOpts_(connOpts), subListener_("Subscription") {}
+};
+
 int main(int, char**) {
     cout << "Project name: " << PROJECT_NAME << " Version: " << PROJECT_VER << endl;
-    cout << "Just adding some more text for another breakpoint location" << endl;
+
+    // A subscriber often wants the server to remember its messages when its
+	// disconnected. In that case, it needs a unique ClientID and a
+	// non-clean session.
+
+	mqtt::async_client cli(SERVER_ADDRESS, CLIENT_ID);
+
+	mqtt::connect_options connOpts;
+	connOpts.set_clean_session(false);
+
+	// Install the callback(s) before connecting.
+	callback cb(cli, connOpts);
+	cli.set_callback(cb);
+
+	// Start the connection.
+	// When completed, the callback will subscribe to topic.
+
+	try {
+		std::cout << "Connecting to the MQTT server..." << std::flush;
+		cli.connect(connOpts, nullptr, cb);
+	}
+	catch (const mqtt::exception& exc) {
+		std::cerr << "\nERROR: Unable to connect to MQTT server: '"
+			<< SERVER_ADDRESS << "'" << exc << std::endl;
+		return 1;
+	}
+
+	// Just block till user tells us to quit.
+
+	while (std::tolower(std::cin.get()) != 'q')
+		;
+
+	// Disconnect
+
+	try {
+		std::cout << "\nDisconnecting from the MQTT server..." << std::flush;
+		cli.disconnect()->wait();
+		std::cout << "OK" << std::endl;
+	}
+	catch (const mqtt::exception& exc) {
+		std::cerr << exc << std::endl;
+		return 1;
+	}
+
+ 	return 0;
 }

toolchain.cmake

@@ -21,6 +21,6 @@ MESSAGE(STATUS "Toolchain build type:${CMAKE_BUILD_TYPE}")
 SET(CMAKE_C_FLAGS ${CMAKE_CXX_FLAGS})
 SET(CMAKE_EXE_LINKER_FLAGS "--sysroot=${sysroot_target}")
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)