pax_global_header 0000666 0000000 0000000 00000000064 14024150334 0014506 g ustar 00root root 0000000 0000000 52 comment=d7a36de882b3f8818d485b0ec94f3fa5fe1152dd
hfd-service-0.1.0/ 0000775 0000000 0000000 00000000000 14024150334 0013703 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/.gitignore 0000664 0000000 0000000 00000000610 14024150334 0015670 0 ustar 00root root 0000000 0000000
# Created by https://www.gitignore.io/api/cmake
# Edit at https://www.gitignore.io/?templates=cmake
### CMake ###
CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
CMakeScripts
Testing
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
_deps
### CMake Patch ###
# External projects
*-prefix/
# End of https://www.gitignore.io/api/cmake
build
build-*
hfd-service-0.1.0/CMakeLists.txt 0000664 0000000 0000000 00000002155 14024150334 0016446 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 3.0)
project(hfd-service)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
include(FindPkgConfig)
include(GNUInstallDirs)
pkg_check_modules(UDEV REQUIRED libudev)
option(ENABLE_LIBHYBRIS "Enable libhybris support" ON)
if (ENABLE_LIBHYBRIS)
pkg_check_modules(ANDROID_HEADERS android-headers)
pkg_check_modules(ANDROID_HARDWARE libhardware)
if(ANDROID_HEADERS_FOUND AND ANDROID_HARDWARE_FOUND)
message(STATUS "Bulding with libhybris support")
set(HAVE_LIBHYBRIS true)
else()
message(WARNING "Bulding without libhybris support, missing required dependencies!")
endif()
else()
message(STATUS "Bulding without libhybris support")
endif()
find_package(Qt5Core REQUIRED)
find_package(Qt5DBus REQUIRED)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
add_subdirectory(src)
add_subdirectory(tools)
add_subdirectory(qt)
# Dbus file
install(FILES data/hfd-service.conf
DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/init
)
# Dbus policy
install(FILES data/com.lomiri.hfd.conf
DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d
)
hfd-service-0.1.0/Jenkinsfile 0000664 0000000 0000000 00000005717 14024150334 0016101 0 ustar 00root root 0000000 0000000 String stashFileList = '*.gz,*.bz2,*.xz,*.deb,*.ddeb,*.dsc,*.changes,*.buildinfo,lintian.txt'
String archiveFileList = '*.gz,*.bz2,*.xz,*.deb,*.ddeb,*.dsc,*.changes,*.buildinfo'
pipeline {
agent any
stages {
stage('Build source') {
steps {
sh '/usr/bin/build-source.sh'
stash(name: 'source', includes: stashFileList)
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
}
}
stage('Build binary - armhf') {
steps {
parallel(
"Build binary - armhf": {
node(label: 'arm64') {
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
unstash 'source'
sh '''export architecture="armhf"
build-binary.sh'''
stash(includes: stashFileList, name: 'build-armhf')
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
}
},
"Build binary - arm64": {
node(label: 'arm64') {
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
unstash 'source'
sh '''export architecture="arm64"
build-binary.sh'''
stash(includes: stashFileList, name: 'build-arm64')
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
}
},
"Build binary - amd64": {
node(label: 'amd64') {
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
unstash 'source'
sh '''export architecture="amd64"
build-binary.sh'''
stash(includes: stashFileList, name: 'build-amd64')
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
}
}
)
}
}
stage('Results') {
steps {
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
unstash 'build-armhf'
unstash 'build-arm64'
unstash 'build-amd64'
archiveArtifacts(artifacts: archiveFileList, fingerprint: true, onlyIfSuccessful: true)
sh '''/usr/bin/build-repo.sh'''
}
}
stage('Cleanup') {
steps {
cleanWs(cleanWhenAborted: true, cleanWhenFailure: true, cleanWhenNotBuilt: true, cleanWhenSuccess: true, cleanWhenUnstable: true, deleteDirs: true)
}
}
}
}
hfd-service-0.1.0/Readme.md 0000664 0000000 0000000 00000001107 14024150334 0015421 0 ustar 00root root 0000000 0000000 # hfd-service
**H**uman **f**eedback **d**evice **service** is a dbus activated service that manages human feedback devices sutch as leds and vibrators on mobile devices.
This replaces usensord and unity8's own led/light handeler
## Why?
We have a need for a more modular system running service now that we have different devices handeling implementations differently.
Secondly we could not use unity8's own led handeler as this only runs in userspace and we wont have access to sysfs devices from there in a secure maner. We can use a dbus service protected with apparmor.
hfd-service-0.1.0/data/ 0000775 0000000 0000000 00000000000 14024150334 0014614 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/data/com.lomiri.hfd.conf 0000664 0000000 0000000 00000000737 14024150334 0020302 0 ustar 00root root 0000000 0000000
hfd-service-0.1.0/data/com.lomiri.hfd.xml 0000664 0000000 0000000 00000001601 14024150334 0020144 0 ustar 00root root 0000000 0000000
hfd-service-0.1.0/data/hfd-service.conf 0000664 0000000 0000000 00000000673 14024150334 0017670 0 ustar 00root root 0000000 0000000 description "hfd service for feedback support"
start on started dbus
stop on stopped dbus
pre-start script
# If we're running on Android-based device, we want to wait until the
# Android container is up.
if [ -e /system/build.prop ]; then
while ! initctl status lxc-android-config| \
grep -q ' start/running,\| start/post-start,'; do
sleep 0.1
done
fi
end script
exec hfd-service
hfd-service-0.1.0/debian/ 0000775 0000000 0000000 00000000000 14024150334 0015125 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/debian/changelog 0000664 0000000 0000000 00000000214 14024150334 0016774 0 ustar 00root root 0000000 0000000 hfd-service (0.1.0) xenial; urgency=medium
* initial release
-- Marius Gripsgard Sat, 21 Mar 2020 02:06:32 +0100
hfd-service-0.1.0/debian/compat 0000664 0000000 0000000 00000000002 14024150334 0016323 0 ustar 00root root 0000000 0000000 9
hfd-service-0.1.0/debian/control 0000664 0000000 0000000 00000002621 14024150334 0016531 0 ustar 00root root 0000000 0000000 Source: hfd-service
Section: admin
Priority: optional
Build-Depends: cmake (>= 2.8.10),
debhelper (>= 9),
pkg-config,
libandroid-properties-dev,
libhardware-dev,
android-headers,
libudev-dev,
qtbase5-dev,
qtfeedback5-dev,
cmake-extras,
qtdeclarative5-dev
Maintainer: Marius Gripsgard
Standards-Version: 3.9.5
Homepage: https://github.com/ubports/deviceinfo
Package: hfd-service
Section: libs
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
Description: Library to detect and configure devices
Library to detect and configure devices
Package: libqt5feedback5-hfd
Section: libs
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
hfd-service,
Description: Library to detect and configure devices
Library to detect and configure devices
Package: qml-module-hfd
Section: libs
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
hfd-service,
Description: Library to detect and configure devices
Library to detect and configure devices
Package: hfd-service-tools
Section: admin
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
hfd-service,
Description: Tools to detect and configure devices
Tools to detect and configure devices
hfd-service-0.1.0/debian/copyright 0000664 0000000 0000000 00000002056 14024150334 0017063 0 ustar 00root root 0000000 0000000 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: deviceinfo
Upstream-Contact: Marius Gripsgard
Source: https://github.com/ubports/deviceinfo
Files: *
Copyright: 2019 UBports foundation, Marius Gripsgard
License: GPL-3
License: GPL-3
This program is free software: you can redistribute it and/or modify it
under the terms of the the GNU General Public License version 3, as
published by the Free Software Foundation.
.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranties of
MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
PURPOSE. See the applicable version of the GNU Lesser General Public
License for more details.
.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
.
On Debian systems, the complete text of the GNU General Public License
can be found in `/usr/share/common-licenses/GPL-3'
hfd-service-0.1.0/debian/hfd-service-tools.install 0000664 0000000 0000000 00000000034 14024150334 0022047 0 ustar 00root root 0000000 0000000 usr/bin/hfd-service-tools-*
hfd-service-0.1.0/debian/hfd-service.install 0000664 0000000 0000000 00000000126 14024150334 0020713 0 ustar 00root root 0000000 0000000 usr/bin/hfd-service
etc/init/hfd-service.conf
etc/dbus-1/system.d/com.lomiri.hfd.conf
hfd-service-0.1.0/debian/libqt5feedback5-hfd.install 0000664 0000000 0000000 00000000065 14024150334 0022207 0 ustar 00root root 0000000 0000000 /usr/lib/*/qt5/plugins/feedback/libqtfeedback_hfd.so
hfd-service-0.1.0/debian/qml-module-hfd.install 0000664 0000000 0000000 00000000031 14024150334 0021322 0 ustar 00root root 0000000 0000000 /usr/lib/*/qt5/qml/Hfd/*
hfd-service-0.1.0/debian/rules 0000775 0000000 0000000 00000000114 14024150334 0016201 0 ustar 00root root 0000000 0000000 #!/usr/bin/make -f
%:
dh $@ --parallel --buildsystem cmake --fail-missing
hfd-service-0.1.0/qt/ 0000775 0000000 0000000 00000000000 14024150334 0014327 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/qt/CMakeLists.txt 0000664 0000000 0000000 00000000070 14024150334 0017064 0 ustar 00root root 0000000 0000000 add_subdirectory(feedback-plugin)
add_subdirectory(qml)
hfd-service-0.1.0/qt/demo/ 0000775 0000000 0000000 00000000000 14024150334 0015253 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/qt/demo/feedback.qml 0000664 0000000 0000000 00000001637 14024150334 0017521 0 ustar 00root root 0000000 0000000 import QtQuick 2.7
import Ubuntu.Components 1.3
import QtFeedback 5.0
MainView {
id: root
objectName: 'mainView'
applicationName: "app"
automaticOrientation: true
width: units.gu(45)
height: units.gu(75)
Page {
anchors.fill: parent
header: PageHeader {
id: header
title: i18n.tr("led test")
}
Column {
anchors {
top: header.bottom
left: parent.left
right: parent.right
bottom: parent.bottom
}
Button {
text: "feedback"
onClicked: haptic.start();
}
}
HapticsEffect {
id: haptic
attackIntensity: 0.0
attackTime: 50
intensity: 1.0
duration: 100
fadeTime: 50
fadeIntensity: 0.0
}
}
}
hfd-service-0.1.0/qt/demo/leds.qml 0000664 0000000 0000000 00000001204 14024150334 0016712 0 ustar 00root root 0000000 0000000 import QtQuick 2.7
import Ubuntu.Components 1.3
import Hfd 0.1
MainView {
id: root
objectName: 'mainView'
applicationName: "app"
automaticOrientation: true
width: units.gu(45)
height: units.gu(75)
Page {
anchors.fill: parent
header: PageHeader {
id: header
title: i18n.tr("led test")
}
Column {
anchors.fill: parent
Button {
text: "on"
onClicked: Leds.state = Leds.state == 0 ? 1 : 0
}
Label {
text: "state: " + Leds.state
}
}
}
}
hfd-service-0.1.0/qt/feedback-plugin/ 0000775 0000000 0000000 00000000000 14024150334 0017347 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/qt/feedback-plugin/CMakeLists.txt 0000664 0000000 0000000 00000001700 14024150334 0022105 0 ustar 00root root 0000000 0000000 find_package(PkgConfig)
find_package(Qt5Core REQUIRED)
find_package(Qt5DBus REQUIRED)
find_package(Qt5Feedback REQUIRED)
qt5_add_resources(FEEDBACK_RESOURCES feedback.qrc)
set(QTFEEDBACK_HFD_SRC
hfd_feedback.h
hfd_feedback.cpp
)
qt5_add_dbus_interface(QTFEEDBACK_HFD_SRC
${CMAKE_SOURCE_DIR}/data/com.lomiri.hfd.xml hfdInterface
)
add_library(
qtfeedback_hfd SHARED
${QTFEEDBACK_HFD_SRC}
${FEEDBACK_RESOURCES}
)
# Ideally, we would read the plugin installation location from cmake
# but this does not work currently.
set(PLUGIN_INSTALL_LOCATION "${CMAKE_INSTALL_LIBDIR}/qt5/plugins/feedback")
# get_target_property(PLUGIN_LOCATION Qt5::Feedback PLUGIN_LOCATION)
message(STATUS "Installing Qt5 feedback plugin to: ${PLUGIN_INSTALL_LOCATION}")
target_link_libraries(
qtfeedback_hfd
${CMAKE_THREAD_LIBS_INIT}
Qt5::Core
Qt5::DBus
Qt5::Feedback
)
install(
TARGETS qtfeedback_hfd
LIBRARY DESTINATION ${PLUGIN_INSTALL_LOCATION})
hfd-service-0.1.0/qt/feedback-plugin/feedback.json 0000664 0000000 0000000 00000000060 14024150334 0021762 0 ustar 00root root 0000000 0000000 { "Interfaces": ["QFeedbackHapticsInterface"] }
hfd-service-0.1.0/qt/feedback-plugin/feedback.qrc 0000664 0000000 0000000 00000000141 14024150334 0021576 0 ustar 00root root 0000000 0000000
feedback.json
hfd-service-0.1.0/qt/feedback-plugin/hfd_feedback.cpp 0000664 0000000 0000000 00000012777 14024150334 0022436 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "hfd_feedback.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hfdInterface.h"
hfd::Feedback::Feedback() : QObject(),
enabled(false),
state(QFeedbackEffect::Stopped)
{
m_interface = std::make_shared("com.lomiri.hfd", "/com/lomiri/hfd",
QDBusConnection::systemBus(), this);
actuatorList << createFeedbackActuator(this, 42);
}
hfd::Feedback::~Feedback()
{
}
QFeedbackInterface::PluginPriority hfd::Feedback::pluginPriority()
{
return PluginHighPriority;
}
QList hfd::Feedback::actuators()
{
return actuatorList;
}
void hfd::Feedback::setActuatorProperty(const QFeedbackActuator&, ActuatorProperty prop, const QVariant &value)
{
switch (prop)
{
case Enabled:
enabled = value.toBool();
break;
default:
break;
}
}
QVariant hfd::Feedback::actuatorProperty(const QFeedbackActuator &actuator, ActuatorProperty prop)
{
QVariant result;
switch (prop)
{
case Name: result = QString::fromLocal8Bit("Hfd Vibrator"); break;
case State: result = actuator.isValid() ? QFeedbackActuator::Ready : QFeedbackActuator::Unknown; break;
case Enabled: result = enabled; break;
}
return result;
}
bool hfd::Feedback::isActuatorCapabilitySupported(const QFeedbackActuator &, QFeedbackActuator::Capability cap)
{
bool result = false;
switch(cap)
{
case QFeedbackActuator::Envelope: result = true; break;
case QFeedbackActuator::Period: result = false; break;
}
return result;
}
void hfd::Feedback::updateEffectProperty(const QFeedbackHapticsEffect *, EffectProperty)
{
}
void hfd::Feedback::hapticsVibrateReply(QDBusPendingCallWatcher *watcher, int period, int repeat)
{
QDBusPendingReply<> reply = *watcher;
if (reply.isError()) {
qWarning() << "Failed to vibrate with pattern:" << reply.error().message();
state = QFeedbackEffect::Stopped;
} else {
if ((repeat == QFeedbackEffect::Infinite) || (--repeat > 0))
QTimer::singleShot(period*2, [=]() { vibrate(period, repeat); });
else
state = QFeedbackEffect::Stopped;
}
watcher->deleteLater();
}
void hfd::Feedback::vibrate(int period, int repeat)
{
if (!(period && repeat))
state = QFeedbackEffect::Stopped;
if (state != QFeedbackEffect::Running) {
// Maybe stopped/paused before this async call.
return;
}
QDBusInterface iface("com.lomiri.hfd",
"/com/lomiri/hfd",
"com.lomiri.hfd.Vibrator");
QDBusPendingCall call = m_interface->vibrate(period);
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call, this);
connect(watcher, &QDBusPendingCallWatcher::finished,
[=](){ hapticsVibrateReply(watcher, period, repeat); });
}
void hfd::Feedback::startVibration(const QFeedbackHapticsEffect *effect)
{
int duration = effect->duration();
if (duration == 0)
duration = 150;
int period = effect->period();
int repeat;
if ((duration == QFeedbackEffect::Infinite) || (duration < 0)) {
// If duration is set to QFeedbackEffect::Infinite or a negative
// value, we repeat this effect forever until stopped. The
// effective period should have been set to a positive value or
// 150ms by default.
duration = QFeedbackEffect::Infinite;
repeat = QFeedbackEffect::Infinite;
if (period <= 0)
period = 150;
} else if (period <= 0) {
// If duration is set to a positive value and period is invalid,
// then use duration as period.
repeat = 1;
period = duration;
} else {
// Otherwise, repeat this effect as many times as the duration
// may cover the effect period.
repeat = (duration + period - 1) / period;
}
vibrate(period, repeat);
}
void hfd::Feedback::setEffectState(const QFeedbackHapticsEffect *effect, QFeedbackEffect::State state)
{
this->state = state;
switch (state)
{
case QFeedbackEffect::Stopped:
break;
case QFeedbackEffect::Paused:
break;
case QFeedbackEffect::Running:
QTimer::singleShot(0, [=]() { startVibration(effect); });
break;
case QFeedbackEffect::Loading:
break;
}
}
QFeedbackEffect::State hfd::Feedback::effectState(const QFeedbackHapticsEffect *)
{
return state;
}
hfd-service-0.1.0/qt/feedback-plugin/hfd_feedback.h 0000664 0000000 0000000 00000004230 14024150334 0022064 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
#include
#include
#include
#include
class QDBusPendingCallWatcher;
class ComLomiriHfdVibratorInterface;
namespace hfd
{
class Feedback : public QObject, public QFeedbackHapticsInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QtFeedbackPlugin" FILE "feedback.json")
Q_INTERFACES(QFeedbackHapticsInterface)
public:
Feedback();
virtual ~Feedback();
// From QFeedbackHapticsInterface
virtual PluginPriority pluginPriority();
QList actuators();
QFeedbackEffect::State effectState(const QFeedbackHapticsEffect *);
void setEffectState (const QFeedbackHapticsEffect* effect, QFeedbackEffect::State state);
bool isActuatorCapabilitySupported(const QFeedbackActuator &, QFeedbackActuator::Capability);
void setActuatorProperty(const QFeedbackActuator &, ActuatorProperty, const QVariant &);
QVariant actuatorProperty(const QFeedbackActuator &, ActuatorProperty);
void updateEffectProperty(const QFeedbackHapticsEffect* effect, EffectProperty property);
private:
std::shared_ptr m_interface;
QList actuatorList;
void hapticsVibrateReply(QDBusPendingCallWatcher *watcher, int period, int repeat);
void vibrate(int period, int repeat);
void startVibration(const QFeedbackHapticsEffect *effect);
bool enabled;
QFeedbackEffect::State state;
};
}
hfd-service-0.1.0/qt/qml/ 0000775 0000000 0000000 00000000000 14024150334 0015120 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/qt/qml/CMakeLists.txt 0000664 0000000 0000000 00000000634 14024150334 0017663 0 ustar 00root root 0000000 0000000 find_package(QmlPlugins)
find_package(Qt5Gui REQUIRED)
set(HFD_QML_SRC
plugin.cpp
leds.cpp
)
qt5_add_dbus_interface(HFD_QML_SRC
${CMAKE_SOURCE_DIR}/data/com.lomiri.hfd.xml hfdInterface
)
add_library(hfd-qml MODULE
${HFD_QML_SRC}
)
target_link_libraries(hfd-qml
hfd-core
Qt5::Core
Qt5::Gui
Qt5::DBus
)
add_qmlplugin(
Hfd
1.0
Hfd
TARGET_PREFIX Hfd
TARGETS hfd-qml
)
hfd-service-0.1.0/qt/qml/leds.cpp 0000664 0000000 0000000 00000004405 14024150334 0016556 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "leds.h"
#include
#include "hfdInterface.h"
Leds::Leds(QObject* parent)
: QObject(parent),
m_color("blue"),
m_state(Leds::Off),
m_onMs(1000),
m_offMs(3000)
{
m_interface = std::make_shared("com.lomiri.hfd", "/com/lomiri/hfd",
QDBusConnection::systemBus(), this);
}
void Leds::setState(Leds::State newState)
{
if (m_state != newState) {
// Make sure all values are up-to-date before setting state on
if (newState == State::On) {
m_interface->setColor(m_color.rgba());
m_interface->setOnMs(m_onMs);
m_interface->setOffMs(m_offMs);
}
m_interface->setState(newState);
m_state = newState;
Q_EMIT stateChanged(m_state);
}
}
Leds::State Leds::state() const
{
return m_state;
}
void Leds::setColor(const QColor &color)
{
if (m_color != color) {
m_interface->setColor(color.rgba());
m_color = color;
Q_EMIT colorChanged(m_color);
}
}
QColor Leds::color() const
{
return m_color;
}
int Leds::onMillisec() const
{
return m_onMs;
}
void Leds::setOnMillisec(int onMs)
{
if (m_onMs != onMs) {
m_interface->setOnMs(onMs);
m_onMs = onMs;
Q_EMIT onMillisecChanged(m_onMs);
}
}
int Leds::offMillisec() const
{
return m_offMs;
}
void Leds::setOffMillisec(int offMs)
{
if (m_offMs != offMs) {
m_interface->setOffMs(offMs);
m_offMs = offMs;
Q_EMIT offMillisecChanged(m_offMs);
}
}
hfd-service-0.1.0/qt/qml/leds.h 0000664 0000000 0000000 00000003626 14024150334 0016227 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
#include
#include
#include
class ComLomiriHfdLedsInterface;
class Leds: public QObject
{
Q_OBJECT
Q_PROPERTY(State state READ state WRITE setState NOTIFY stateChanged)
Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
Q_PROPERTY(int onMillisec READ onMillisec WRITE setOnMillisec NOTIFY onMillisecChanged)
Q_PROPERTY(int offMillisec READ offMillisec WRITE setOffMillisec NOTIFY offMillisecChanged)
public:
enum State {
Off = 0,
On = 1,
};
Q_ENUM(State)
explicit Leds(QObject *parent = 0);
void setState(State newState);
State state() const;
void setColor(const QColor &color);
QColor color() const;
int onMillisec() const;
void setOnMillisec(int onMs);
int offMillisec() const;
void setOffMillisec(int offMs);
Q_SIGNALS:
void stateChanged(State newState);
void colorChanged(const QColor &color);
void onMillisecChanged(int onMs);
void offMillisecChanged(int offMs);
private:
std::shared_ptr m_interface;
QColor m_color;
State m_state;
int m_onMs;
int m_offMs;
void turnOff();
void turnOn();
};
hfd-service-0.1.0/qt/qml/plugin.cpp 0000664 0000000 0000000 00000002073 14024150334 0017124 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "plugin.h"
#include "leds.h"
#include
static QObject *leds_provider(QQmlEngine *engine, QJSEngine *scriptEngine)
{
Q_UNUSED(engine)
Q_UNUSED(scriptEngine)
return new Leds();
}
void HfdPlugin::registerTypes(const char *uri)
{
Q_ASSERT(uri == QLatin1String("Hfd"));
qmlRegisterSingletonType(uri, 0, 1, "Leds", leds_provider);
}
hfd-service-0.1.0/qt/qml/plugin.h 0000664 0000000 0000000 00000001717 14024150334 0016575 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
#include
#include
class HfdPlugin : public QQmlExtensionPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
public:
void registerTypes(const char *uri) override;
};
hfd-service-0.1.0/qt/qml/qmldir 0000664 0000000 0000000 00000000060 14024150334 0016327 0 ustar 00root root 0000000 0000000 module Hfd
plugin hfd-qml
typeinfo hfd.qmltypes
hfd-service-0.1.0/src/ 0000775 0000000 0000000 00000000000 14024150334 0014472 5 ustar 00root root 0000000 0000000 hfd-service-0.1.0/src/CMakeLists.txt 0000664 0000000 0000000 00000001636 14024150334 0017240 0 ustar 00root root 0000000 0000000 add_subdirectory(udev)
if (HAVE_LIBHYBRIS)
include_directories(
${ANDROID_HEADERS_INCLUDE_DIRS}
)
set(LIBHYBRIS_SRC
leds-hybris.cpp
)
set(LIBHYBRIS_LIBRARIES
${ANDROID_HARDWARE_LIBRARIES}
)
add_definitions(-DHAVE_LIBHYBRIS)
endif()
add_library(hfd-core STATIC
leds.cpp
leds-sysfs.cpp
vibrator.cpp
vibrator-ff.cpp
vibrator-sysfs.cpp
vibrator-legacy.cpp
${LIBHYBRIS_SRC}
)
target_link_libraries(hfd-core
udev-cpp
${LIBHYBRIS_LIBRARIES}
)
set(SERVICE_SRC
service.cpp
dbusAdaptor.h
)
qt5_add_dbus_adaptor(SERVICE_SRC
${CMAKE_SOURCE_DIR}/data/com.lomiri.hfd.xml ${CMAKE_CURRENT_SOURCE_DIR}/dbusAdaptor.h DbusAdaptor
)
add_executable(hfd-service
${SERVICE_SRC}
)
target_link_libraries(hfd-service
hfd-core
Qt5::Core
Qt5::DBus
)
install(TARGETS hfd-service RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
hfd-service-0.1.0/src/common.h 0000664 0000000 0000000 00000001417 14024150334 0016136 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
namespace hfd {
enum State {
Off,
On
};
}
hfd-service-0.1.0/src/dbusAdaptor.h 0000664 0000000 0000000 00000002235 14024150334 0017115 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
#include
class DbusAdaptor : public QObject
{
Q_OBJECT
public:
DbusAdaptor(QObject *parent = 0) : QObject(parent) {};
public Q_SLOTS:
virtual void vibrate() = 0;
virtual void vibrate(int durationMs) = 0;
virtual void rumble(int durationMs, int repeat) = 0;
virtual void setState(int state) = 0;
virtual void setColor(unsigned int color) = 0;
virtual void setOnMs(int ms) = 0;
virtual void setOffMs(int ms) = 0;
};
hfd-service-0.1.0/src/leds-hybris.cpp 0000664 0000000 0000000 00000006162 14024150334 0017430 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "leds-hybris.h"
#include
#include
extern "C" {
#include
#include
#include
}
// legacy hybris support
namespace hfd {
light_device_t* getLightDevice() {
int err;
hw_module_t* module;
light_device_t* lightDevice;
err = hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
if (err == 0) {
hw_device_t* device;
err = module->methods->open(module, LIGHT_ID_NOTIFICATIONS, &device);
if (err == 0 && device) {
lightDevice = (light_device_t*)device;
return lightDevice;
} else {
std::cout << "Failed to access notification lights" << std::endl;
}
} else {
std::cout << "Failed to initialize lights hardware." << std::endl;
}
return nullptr;
}
bool LedsHybris::usable() {
light_device_t* lightDevice = getLightDevice();
const bool loaded = (lightDevice != nullptr);
if (lightDevice) {
hw_device_t* device = (hw_device_t*) lightDevice;
device->close(device);
}
return loaded;
}
LedsHybris::LedsHybris() : Leds() {
if (m_lightDevice) {
return;
}
m_lightDevice = getLightDevice();
if (m_lightDevice)
turnOff();
// Get up to date
configure();
}
LedsHybris::~LedsHybris()
{
if (m_lightDevice) {
hw_device_t* device = (hw_device_t*) m_lightDevice;
device->close(device);
}
}
void LedsHybris::configure() {
if (m_state == State::On)
turnOn();
else
turnOff();
}
void LedsHybris::turnOn()
{
// pulse
light_state_t state;
memset(&state, 0, sizeof(light_state_t));
state.color = m_color;
state.flashMode = LIGHT_FLASH_TIMED;
state.flashOnMS = m_onMs;
state.flashOffMS = m_offMs;
state.brightnessMode = BRIGHTNESS_MODE_USER;
if (!m_lightDevice)
return;
if (m_lightDevice->set_light(m_lightDevice, &state) != 0) {
std::cout << "Failed to turn the light off";
}
}
void LedsHybris::turnOff()
{
light_state_t state;
memset(&state, 0, sizeof(light_state_t));
state.color = 0x00000000;
state.flashMode = LIGHT_FLASH_NONE;
state.flashOnMS = 0;
state.flashOffMS = 0;
state.brightnessMode = 0;
if (!m_lightDevice)
return;
if (m_lightDevice->set_light(m_lightDevice, &state) != 0) {
std::cout << "Failed to turn the light off";
}
}
}
hfd-service-0.1.0/src/leds-hybris.h 0000664 0000000 0000000 00000001761 14024150334 0017075 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "leds.h"
struct light_device_t;
namespace hfd {
class LedsHybris : public Leds {
public:
LedsHybris();
~LedsHybris();
static bool usable();
protected:
void configure() override;
private:
void turnOn();
void turnOff();
light_device_t* m_lightDevice = nullptr;
};
}
hfd-service-0.1.0/src/leds-sysfs.cpp 0000664 0000000 0000000 00000010200 14024150334 0017263 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#include "leds-sysfs.h"
#include "utils.h"
#include
#include
#include
static bool has_timer_trigger(Udev::UdevDevice const& dev) {
std::string trigger_value;
try {
// get_sysattr() always gives the full list of available values.
trigger_value = dev.get_sysattr("trigger");
} catch (std::runtime_error const&) {
return false;
}
/*
* Word "timer" maybe at the start or the end, in the middle surrounded by
* spaces, or surrounded by '[' and ']'.
*/
static std::regex timer_re("(^|[[ ])timer([] ]|$)", std::regex_constants::extended);
return std::regex_search(trigger_value, timer_re);
}
namespace hfd {
bool LedsSysfs::usable() {
if (access("/sys/class/leds", F_OK ) == -1)
return false;
Udev::Udev udev;
Udev::UdevEnumerate enumerator = udev.enumerate_new();
enumerator.add_match_sysattr("subsystem","leds");
enumerator.scan_devices();
bool red, green, blue = false;
for (auto dev : enumerator.enumerate_devices()) {
auto splitted = utils::split(dev.get_sysname(), ':');
for (auto color : splitted) {
std::cout << "got: " << color << std::endl;
if (color == "red")
red = has_timer_trigger(dev);
if (color == "green")
green = has_timer_trigger(dev);
if (color == "blue")
blue = has_timer_trigger(dev);
}
}
return (red && green && blue);
}
LedsSysfs::LedsSysfs(): Leds() {
Udev::Udev udev;
Udev::UdevEnumerate enumerator = udev.enumerate_new();
enumerator.add_match_sysattr("subsystem","leds");
enumerator.scan_devices();
for (auto dev : enumerator.enumerate_devices()) {
auto splitted = utils::split(dev.get_sysname(), ':');
for (auto color : splitted) {
std::cout << "got: " << color << std::endl;
if (color == "red")
m_rgbDevices[Colors::RED] = dev;
if (color == "green")
m_rgbDevices[Colors::GREEN] = dev;
if (color == "blue")
m_rgbDevices[Colors::BLUE] = dev;
}
}
for (auto dev : m_rgbDevices) {
dev.second.set_sysattr("trigger", "timer");
}
m_timer = true;
// Get up to date
configure();
}
// Over simplyfied led controlls!
void LedsSysfs::configure() {
if (m_state == State::On) {
std::cout << "red: " << std::to_string(rgba::Red(m_color)) << std::endl;
std::cout << "green: " << std::to_string(rgba::Green(m_color)) << std::endl;
std::cout << "blue: " << std::to_string(rgba::Blue(m_color)) << std::endl;
setDelay();
setLed(Colors::RED, rgba::Red(m_color));
setLed(Colors::GREEN, rgba::Green(m_color));
setLed(Colors::BLUE, rgba::Blue(m_color));
} else {
m_rgbDevices[Colors::RED].set_sysattr("brightness", "0");
m_rgbDevices[Colors::GREEN].set_sysattr("brightness", "0");
m_rgbDevices[Colors::BLUE].set_sysattr("brightness", "0");
}
}
void LedsSysfs::setDelay()
{
if (m_timer) {
for (auto dev : m_rgbDevices) {
dev.second.set_sysattr("trigger", "timer");
dev.second.set_sysattr("delay_on", std::to_string(m_onMs));
dev.second.set_sysattr("delay_off", std::to_string(m_offMs));
}
}
}
void LedsSysfs::setLed(Colors color, int value)
{
m_rgbDevices[color].set_sysattr("brightness", std::to_string(value));
}
}
hfd-service-0.1.0/src/leds-sysfs.h 0000664 0000000 0000000 00000002156 14024150334 0016743 0 ustar 00root root 0000000 0000000 /*
* Copyright 2020 UBports foundation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Marius Gripsgard
*/
#pragma once
#include "leds.h"
#include