From 0b5b92ccd75ba875ade79e2ed6f43ef9a0797c59 Mon Sep 17 00:00:00 2001 From: Slava Monich Date: Tue, 26 May 2015 14:44:38 +0300 Subject: [PATCH] [usb-moded-qt5] Initial commit. JB#29035 --- .gitignore | 2 + libusb-moded-qt.pro | 4 + rpm/libusb-moded-qt5.spec | 55 ++++++ src/qusbmoded.cpp | 355 ++++++++++++++++++++++++++++++++++++++ src/qusbmoded.h | 158 +++++++++++++++++ src/qusbmoded_debug.h | 57 ++++++ src/qusbmoded_types.h | 45 +++++ src/src.pro | 47 +++++ 8 files changed, 723 insertions(+) create mode 100644 .gitignore create mode 100644 libusb-moded-qt.pro create mode 100644 rpm/libusb-moded-qt5.spec create mode 100644 src/qusbmoded.cpp create mode 100644 src/qusbmoded.h create mode 100644 src/qusbmoded_debug.h create mode 100644 src/qusbmoded_types.h create mode 100644 src/src.pro diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5ea16d2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +libusb-moded-qt.pro.user +build diff --git a/libusb-moded-qt.pro b/libusb-moded-qt.pro new file mode 100644 index 0000000..ec90db7 --- /dev/null +++ b/libusb-moded-qt.pro @@ -0,0 +1,4 @@ +TEMPLATE = subdirs +CONFIG += ordered +SUBDIRS += src +OTHER_FILES += rpm/libusb-moded-qt5.spec diff --git a/rpm/libusb-moded-qt5.spec b/rpm/libusb-moded-qt5.spec new file mode 100644 index 0000000..a542f4c --- /dev/null +++ b/rpm/libusb-moded-qt5.spec @@ -0,0 +1,55 @@ +Name: libusb-moded-qt5 + +Summary: A library of Qt5 bindings for usb_moded +Version: 1.0 +Release: 1 +Group: System/Libraries +License: BSD +URL: https://github.com/nemomobile/libusb-moded-qt5 +Source0: %{name}-%{version}.tar.bz2 + +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig +Requires: usb-moded > 0.82 +BuildRequires: pkgconfig(Qt5Core) +BuildRequires: pkgconfig(Qt5DBus) +BuildRequires: pkgconfig(usb_moded) + +%{!?qtc_qmake5:%define qtc_qmake5 %qmake5} +%{!?qtc_make:%define qtc_make make} + +%description +This package contains Qt bindings for usb_moded + +%package devel +Summary: Development files for usb_moded Qt bindings +Group: Development/Libraries +Requires: %{name} = %{version}-%{release} +Requires: %{name} = %{version} + +%description devel +This package contains the development header files for usb_moded Qt bindings. + +%prep +%setup -q -n %{name}-%{version} + +%build +%qtc_qmake5 +%qtc_make %{?_smp_mflags} + +%install +rm -rf %{buildroot} +%qmake5_install + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + +%files +%defattr(-,root,root,-) +%{_libdir}/%{name}.so* + +%files devel +%defattr(-,root,root,-) +%{_libdir}/pkgconfig/usb-moded-qt5.pc +%{_includedir}/usb-moded-qt5/*.h diff --git a/src/qusbmoded.cpp b/src/qusbmoded.cpp new file mode 100644 index 0000000..86cd8e7 --- /dev/null +++ b/src/qusbmoded.cpp @@ -0,0 +1,355 @@ +/* + * Copyright (C) 2015 Jolla Ltd. + * Contact: Slava Monich + * + * You may use this file under the terms of the BSD license as follows: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Nemo Mobile nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "qusbmoded.h" +#include "qusbmoded_debug.h" +#include "usb_moded_interface.h" + +#include "usb_moded-dbus.h" +#include "usb_moded-modes.h" + +#define USB_MODED_CALL_GET_MODES (0x01) +#define USB_MODED_CALL_GET_CONFIG (0x02) +#define USB_MODED_CALL_MODE_REQUEST (0x04) + +class QUsbModed::Private +{ +public: + static const QString UsbModeSection; + static const QString UsbModeKeyMode; + + QStringList iSupportedModes; + QString iConfigMode; + QString iCurrentMode; + QDBusConnection iBus; + QUsbModedInterface* iInterface; + int iPendingCalls; + bool iAvailable; + + Private() : + iBus(QDBusConnection::systemBus()), + iInterface(NULL), + iPendingCalls(0), + iAvailable(false) {} +}; + +// Groups and keys (usb_moded-config.h) +const QString QUsbModed::Private::UsbModeSection("usbmode"); +const QString QUsbModed::Private::UsbModeKeyMode("mode"); + +// States (from usb_moded-dbus.h) +const QString QUsbModed::Mode::Connected(USB_CONNECTED); +const QString QUsbModed::Mode::DataInUse(DATA_IN_USE); +const QString QUsbModed::Mode::Disconnected(USB_DISCONNECTED); +const QString QUsbModed::Mode::ModeRequest(USB_CONNECTED_DIALOG_SHOW); + +// Modes (from usb_moded-modes.h) +const QString QUsbModed::Mode::Undefined(MODE_UNDEFINED); +const QString QUsbModed::Mode::Ask(MODE_ASK); +const QString QUsbModed::Mode::MassStorage(MODE_MASS_STORAGE); +const QString QUsbModed::Mode::Developer(MODE_DEVELOPER); +const QString QUsbModed::Mode::MTP(MODE_MTP); +const QString QUsbModed::Mode::Host(MODE_HOST); +const QString QUsbModed::Mode::ConnectionSharing(MODE_CONNECTION_SHARING); +const QString QUsbModed::Mode::Diag(MODE_DIAG); +const QString QUsbModed::Mode::Adb(MODE_ADB); +const QString QUsbModed::Mode::PCSuite(MODE_PC_SUITE); +const QString QUsbModed::Mode::Charging(MODE_CHARGING); +const QString QUsbModed::Mode::Charger(MODE_CHARGER); + +QUsbModed::QUsbModed(QObject* aParent) : + QObject(aParent), + iPrivate(new Private) +{ + QDBusServiceWatcher* serviceWatcher = + new QDBusServiceWatcher(USB_MODE_SERVICE, iPrivate->iBus, + QDBusServiceWatcher::WatchForRegistration | + QDBusServiceWatcher::WatchForUnregistration, this); + + connect(serviceWatcher, + SIGNAL(serviceRegistered(QString)), + SLOT(onServiceRegistered(QString))); + connect(serviceWatcher, + SIGNAL(serviceUnregistered(QString)), + SLOT(onServiceUnregistered(QString))); + + if (iPrivate->iBus.interface()->isServiceRegistered(USB_MODE_SERVICE)) { + setup(); + } +} + +QUsbModed::~QUsbModed() +{ + delete iPrivate; +} + +QStringList QUsbModed::supportedModes() const +{ + return iPrivate->iSupportedModes; +} + +bool QUsbModed::available() const +{ + return iPrivate->iAvailable; +} + +QString QUsbModed::currentMode() const +{ + return iPrivate->iCurrentMode; +} + +QString QUsbModed::configMode() const +{ + return iPrivate->iConfigMode; +} + +bool QUsbModed::setCurrentMode(QString aMode) +{ + if (iPrivate->iInterface) { + connect(new QDBusPendingCallWatcher( + iPrivate->iInterface->set_mode(aMode), iPrivate->iInterface), + SIGNAL(finished(QDBusPendingCallWatcher*)), + SLOT(onSetModeFinished(QDBusPendingCallWatcher*))); + return true; + } + return false; +} + +bool QUsbModed::setConfigMode(QString aMode) +{ + if (iPrivate->iInterface) { + connect(new QDBusPendingCallWatcher( + iPrivate->iInterface->set_config(aMode), iPrivate->iInterface), + SIGNAL(finished(QDBusPendingCallWatcher*)), + SLOT(onSetConfigFinished(QDBusPendingCallWatcher*))); + return true; + } + return false; +} + +void QUsbModed::onServiceRegistered(QString aService) +{ + DEBUG_(aService); + setup(); +} + +void QUsbModed::onServiceUnregistered(QString aService) +{ + DEBUG_(aService); + iPrivate->iPendingCalls = 0; + if (iPrivate->iInterface) { + delete iPrivate->iInterface; + iPrivate->iInterface = NULL; + } + if (iPrivate->iAvailable) { + iPrivate->iAvailable = false; + Q_EMIT availableChanged(); + } +} + +void QUsbModed::setup() +{ + delete iPrivate->iInterface; // That cancels whatever is in progress + iPrivate->iInterface = new QUsbModedInterface(USB_MODE_SERVICE, + USB_MODE_OBJECT, iPrivate->iBus, this); + connect(iPrivate->iInterface, + SIGNAL(sig_usb_state_ind(QString)), + SLOT(onUsbStateChanged(QString))); + connect(iPrivate->iInterface, + SIGNAL(sig_usb_config_ind(QString,QString,QString)), + SLOT(onUsbConfigChanged(QString,QString,QString))); + connect(iPrivate->iInterface, + SIGNAL(sig_usb_supported_modes_ind(QString)), + SLOT(onUsbSupportedModesChanged(QString))); + connect(iPrivate->iInterface, + SIGNAL(sig_usb_state_error_ind(QString)), + SIGNAL(usbStateError(QString))); + + // Request the current state + iPrivate->iPendingCalls |= USB_MODED_CALL_GET_MODES; + connect(new QDBusPendingCallWatcher( + iPrivate->iInterface->get_modes(), iPrivate->iInterface), + SIGNAL(finished(QDBusPendingCallWatcher*)), + SLOT(onGetModesFinished(QDBusPendingCallWatcher*))); + + iPrivate->iPendingCalls |= USB_MODED_CALL_GET_CONFIG; + connect(new QDBusPendingCallWatcher( + iPrivate->iInterface->get_config(), iPrivate->iInterface), + SIGNAL(finished(QDBusPendingCallWatcher*)), + SLOT(onGetConfigFinished(QDBusPendingCallWatcher*))); + + iPrivate->iPendingCalls |= USB_MODED_CALL_MODE_REQUEST; + connect(new QDBusPendingCallWatcher( + iPrivate->iInterface->mode_request(), iPrivate->iInterface), + SIGNAL(finished(QDBusPendingCallWatcher*)), + SLOT(onGetModeRequestFinished(QDBusPendingCallWatcher*))); +} + +void QUsbModed::onGetModesFinished(QDBusPendingCallWatcher* aCall) +{ + QDBusPendingReply reply(*aCall); + QString modes; + if (!reply.isError()) { + modes = reply.value(); + DEBUG_(modes); + } else { + DEBUG_(reply.error()); + } + updateSupportedModes(modes); + aCall->deleteLater(); + setupCallFinished(USB_MODED_CALL_GET_MODES); +} + +void QUsbModed::onGetConfigFinished(QDBusPendingCallWatcher* aCall) +{ + QDBusPendingReply reply(*aCall); + if (!reply.isError()) { + QString mode = reply.value(); + DEBUG_(mode); + if (iPrivate->iConfigMode != mode) { + iPrivate->iConfigMode = mode; + Q_EMIT configModeChanged(); + } + } else { + DEBUG_(reply.error()); + } + aCall->deleteLater(); + setupCallFinished(USB_MODED_CALL_GET_CONFIG); +} + +void QUsbModed::onGetModeRequestFinished(QDBusPendingCallWatcher* aCall) +{ + QDBusPendingReply reply(*aCall); + if (!reply.isError()) { + QString mode = reply.value(); + DEBUG_(mode); + if (iPrivate->iCurrentMode != mode) { + iPrivate->iCurrentMode = mode; + Q_EMIT currentModeChanged(); + } + if (iPrivate->iCurrentMode != mode) { + iPrivate->iCurrentMode = mode; + Q_EMIT currentModeChanged(); + } + } else { + DEBUG_(reply.error()); + } + aCall->deleteLater(); + setupCallFinished(USB_MODED_CALL_MODE_REQUEST); +} + +void QUsbModed::updateSupportedModes(QString aModes) +{ + const QStringList result = aModes.split(',', QString::SkipEmptyParts); + const int n = result.count(); + QStringList modes; + for (int i=0; iiSupportedModes != modes) { + iPrivate->iSupportedModes = modes; + Q_EMIT supportedModesChanged(); + } +} + +void QUsbModed::setupCallFinished(int aCallId) +{ + ASSERT_(iPrivate->iPendingCalls & aCallId); + iPrivate->iPendingCalls &= ~aCallId; + if (!iPrivate->iPendingCalls) { + DEBUG_("setup done"); + ASSERT_(!iPrivate->iAvailable); + iPrivate->iAvailable = true; + Q_EMIT availableChanged(); + } +} + +void QUsbModed::onSetModeFinished(QDBusPendingCallWatcher* aCall) +{ + QDBusPendingReply reply(*aCall); + if (!reply.isError()) { + QString mode = reply.value(); + DEBUG_(mode); + if (iPrivate->iCurrentMode != mode) { + iPrivate->iCurrentMode = mode; + Q_EMIT currentModeChanged(); + } + } else { + DEBUG_(reply.error()); + } + aCall->deleteLater(); +} + +void QUsbModed::onSetConfigFinished(QDBusPendingCallWatcher* aCall) +{ + QDBusPendingReply reply(*aCall); + if (!reply.isError()) { + QString mode = reply.value(); + DEBUG_(mode); + if (iPrivate->iConfigMode != mode) { + iPrivate->iConfigMode = mode; + Q_EMIT configModeChanged(); + } + } else { + DEBUG_(reply.error()); + } + aCall->deleteLater(); +} + +void QUsbModed::onUsbStateChanged(QString aMode) +{ + DEBUG_(aMode); + if (iPrivate->iCurrentMode != aMode) { + iPrivate->iCurrentMode = aMode; + Q_EMIT currentModeChanged(); + } +} + +void QUsbModed::onUsbSupportedModesChanged(QString aModes) +{ + DEBUG_(aModes); + updateSupportedModes(aModes); +} + +void QUsbModed::onUsbConfigChanged(QString aSect, QString aKey, QString aVal) +{ + DEBUG_(aSect << aKey << aVal); + if (aSect == Private::UsbModeSection && + aKey == Private::UsbModeKeyMode) { + if (iPrivate->iConfigMode != aVal) { + iPrivate->iConfigMode = aVal; + Q_EMIT configModeChanged(); + } + } +} diff --git a/src/qusbmoded.h b/src/qusbmoded.h new file mode 100644 index 0000000..78106a9 --- /dev/null +++ b/src/qusbmoded.h @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2015 Jolla Ltd. + * Contact: Slava Monich + * + * You may use this file under the terms of the BSD license as follows: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Nemo Mobile nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef QUSBMODED_H +#define QUSBMODED_H + +#include "qusbmoded_types.h" + +#include +#include + +class QDBusPendingCallWatcher; + +class QUSBMODED_EXPORT QUsbModed : public QObject +{ + Q_OBJECT + Q_PROPERTY(bool available READ available NOTIFY availableChanged) + Q_PROPERTY(QStringList supportedModes READ supportedModes NOTIFY supportedModesChanged) + Q_PROPERTY(QString currentMode READ currentMode WRITE setCurrentMode NOTIFY currentModeChanged) + Q_PROPERTY(QString configMode READ configMode WRITE setConfigMode NOTIFY configModeChanged) + + // States (from usb_moded-dbus.h) + Q_PROPERTY(QString USB_CONNECTED READ USB_CONNECTED CONSTANT) + Q_PROPERTY(QString DATA_IN_USE READ DATA_IN_USE CONSTANT) + Q_PROPERTY(QString USB_DISCONNECTED READ USB_DISCONNECTED CONSTANT) + Q_PROPERTY(QString USB_CONNECTED_DIALOG_SHOW READ USB_CONNECTED_DIALOG_SHOW CONSTANT) + + // Modes (from usb_moded-modes.h) + Q_PROPERTY(QString MODE_UNDEFINED READ MODE_UNDEFINED CONSTANT) + Q_PROPERTY(QString MODE_ASK READ MODE_ASK CONSTANT) + Q_PROPERTY(QString MODE_MASS_STORAGE READ MODE_MASS_STORAGE CONSTANT) + Q_PROPERTY(QString MODE_DEVELOPER READ MODE_DEVELOPER CONSTANT) + Q_PROPERTY(QString MODE_MTP READ MODE_MTP CONSTANT) + Q_PROPERTY(QString MODE_HOST READ MODE_HOST CONSTANT) + Q_PROPERTY(QString MODE_CONNECTION_SHARING READ MODE_CONNECTION_SHARING CONSTANT) + Q_PROPERTY(QString MODE_DIAG READ MODE_DIAG CONSTANT) + Q_PROPERTY(QString MODE_ADB READ MODE_ADB CONSTANT) + Q_PROPERTY(QString MODE_PC_SUITE READ MODE_PC_SUITE CONSTANT) + Q_PROPERTY(QString MODE_CHARGING READ MODE_CHARGING CONSTANT) + Q_PROPERTY(QString MODE_CHARGER READ MODE_CHARGER CONSTANT) + +public: + class Mode { + public: + // States (from usb_moded-dbus.h) + static const QString Connected; + static const QString DataInUse; + static const QString Disconnected; + static const QString ModeRequest; + + // Modes (from usb_moded-modes.h) + static const QString Undefined; + static const QString Ask; + static const QString MassStorage; + static const QString Developer; + static const QString MTP; + static const QString Host; + static const QString ConnectionSharing; + static const QString Diag; + static const QString Adb; + static const QString PCSuite; + static const QString Charging; + static const QString Charger; + + private: + Mode(); // Disallow instantiation + }; + + explicit QUsbModed(QObject* parent = NULL); + ~QUsbModed(); + + bool available() const; + QStringList supportedModes() const; + QString currentMode() const; + QString configMode() const; + + bool setCurrentMode(QString mode); + bool setConfigMode(QString mode); + +private: + // Getters for QML constants + QString USB_CONNECTED() const { return Mode::Connected; } + QString DATA_IN_USE() const { return Mode::DataInUse; } + QString USB_DISCONNECTED() const { return Mode::Disconnected; } + QString USB_CONNECTED_DIALOG_SHOW() const { return Mode::ModeRequest; } + QString MODE_UNDEFINED() const { return Mode::Undefined; } + QString MODE_ASK() const { return Mode::Ask; } + QString MODE_MASS_STORAGE() const { return Mode::MassStorage; } + QString MODE_DEVELOPER() const { return Mode::Developer; } + QString MODE_MTP() const { return Mode::MTP; } + QString MODE_HOST() const { return Mode::Host; } + QString MODE_CONNECTION_SHARING() const { return Mode::ConnectionSharing; } + QString MODE_DIAG() const { return Mode::Diag; } + QString MODE_ADB() const { return Mode::Adb; } + QString MODE_PC_SUITE() const { return Mode::PCSuite; } + QString MODE_CHARGING() const { return Mode::Charging; } + QString MODE_CHARGER() const { return Mode::Charger; } + +Q_SIGNALS: + void availableChanged(); + void supportedModesChanged(); + void currentModeChanged(); + void configModeChanged(); + void usbStateError(QString error); + +private Q_SLOTS: + void onServiceRegistered(QString service); + void onServiceUnregistered(QString service); + void onGetModesFinished(QDBusPendingCallWatcher* call); + void onGetConfigFinished(QDBusPendingCallWatcher* call); + void onGetModeRequestFinished(QDBusPendingCallWatcher* call); + void onSetModeFinished(QDBusPendingCallWatcher* call); + void onSetConfigFinished(QDBusPendingCallWatcher* call); + void onUsbConfigChanged(QString section, QString key, QString value); + void onUsbStateChanged(QString mode); + void onUsbSupportedModesChanged(QString modes); + +private: + void setup(); + void setupCallFinished(int callId); + void updateSupportedModes(QString modes); + +private: + class Private; + Private* iPrivate; +}; + +#endif // QUSBMODED_H diff --git a/src/qusbmoded_debug.h b/src/qusbmoded_debug.h new file mode 100644 index 0000000..6c0a63c --- /dev/null +++ b/src/qusbmoded_debug.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2015 Jolla Ltd. + * Contact: Slava Monich + * + * You may use this file under the terms of the BSD license as follows: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Nemo Mobile nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef QUSBMODED_DEBUG_H +#define QUSBMODED_DEBUG_H + +#include + +#ifndef QUSBMODED_DEBUG +# define QUSBMODED_DEBUG 0 +#endif // QUSBMODED_DEBUG + +#if QUSBMODED_DEBUG +# if QT_VERSION >= 0x050000 +# define DEBUG_(x) (qDebug() << x) +# else +# define DEBUG_(x) (qDebug() << Q_FUNC_INFO << x) +# endif +# define ASSERT_(x) ((x) ? ((void)0) : qt_assert(#x,__FILE__,__LINE__)) +#else +# define DEBUG_(expr) ((void)0) +# define ASSERT_(expr) ((void)0) +#endif // QUSBMODED_DEBUG + +#define WARN_(x) (qWarning() << x) + +#endif // QUSBMODED_DEBUG_H diff --git a/src/qusbmoded_types.h b/src/qusbmoded_types.h new file mode 100644 index 0000000..d8bbd2e --- /dev/null +++ b/src/qusbmoded_types.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2015 Jolla Ltd. + * Contact: Slava Monich + * + * You may use this file under the terms of the BSD license as follows: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Nemo Mobile nor the names of its contributors + * may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef QUSBMODED_TYPES_H +#define QUSBMODED_TYPES_H + +#include + +#ifdef QUSBMODED_LIBRARY +# define QUSBMODED_EXPORT Q_DECL_EXPORT +#else +# define QUSBMODED_EXPORT Q_DECL_IMPORT +#endif + +#endif // QUSBMODED_TYPES_H diff --git a/src/src.pro b/src/src.pro new file mode 100644 index 0000000..71ee20c --- /dev/null +++ b/src/src.pro @@ -0,0 +1,47 @@ +TEMPLATE = lib +TARGET = usb-moded-qt5 +CONFIG += link_pkgconfig +PKGCONFIG += usb_moded + +QT += dbus +QT -= gui +QMAKE_CXXFLAGS += -Wno-unused-parameter -Wno-psabi + +DEFINES += QUSBMODED_LIBRARY + +CONFIG(debug, debug|release) { + DEFINES += QUSBMODED_DEBUG=1 +} + +SOURCES += \ + qusbmoded.cpp + +PUBLIC_HEADERS += \ + qusbmoded.h \ + qusbmoded_types.h + +HEADERS += \ + $$PUBLIC_HEADERS \ + qusbmoded_debug.h + +USB_MODED_INCLUDE_PATH = $$system(for d in `pkg-config --cflags-only-I usb_moded` ; do echo $d ; done | grep usb.moded | sed s/^-I//g) +DBUS_INTERFACES += com_meego_usb_moded +com_meego_usb_moded.files = $$USB_MODED_INCLUDE_PATH/com.meego.usb_moded.xml +com_meego_usb_moded.header_flags = -N -c QUsbModedInterface +com_meego_usb_moded.source_flags = -N -c QUsbModedInterface + +headers.path = $$INSTALL_ROOT$$PREFIX/include/usb-moded-qt5 +headers.files = $$PUBLIC_HEADERS +INSTALLS += headers + +target.path = $$[QT_INSTALL_LIBS] +INSTALLS += target + +pkgconfig.files = $$TARGET.pc +pkgconfig.path = $$target.path/pkgconfig-qt5 +QMAKE_PKGCONFIG_DESCRIPTION = Qt bindings for usb_moded +QMAKE_PKGCONFIG_INCDIR = $$headers.path +QMAKE_PKGCONFIG_LIBDIR = $$target.path +QMAKE_PKGCONFIG_DESTDIR = pkgconfig +CONFIG += create_pc create_prl no_install_prl +INSTALLS += pkgconfig