summaryrefslogtreecommitdiffstats
path: root/meta-app-framework/recipes-core
diff options
context:
space:
mode:
authorMarius Vlad <marius.vlad@collabora.com>2020-05-12 13:17:54 +0300
committerJan-Simon Moeller <jsmoeller@linuxfoundation.org>2020-05-13 11:53:57 +0000
commit91524b2cbe2b81d9cadcb1e0a1f30df3c00078b5 (patch)
tree3cd178a711b07a4aef6018b85f48d352f04e9fd6 /meta-app-framework/recipes-core
parent9ebcdd9ea2144c7112accd9b2a1a56ae7fea4449 (diff)
qtwayland_%.bbappend: Migrate the qt shell integration to the proper
place The proper place to choose the qtshell integration is with qtwayland so migrate it there. While at it, upgrade to xdg-shell stable instead of using the unstable v6. Bug-AGL: SPEC-3133 Signed-off-by: Marius Vlad <marius.vlad@collabora.com> Change-Id: I67b92cd744c4e34c9a603b9535823d9562d4bdf8
Diffstat (limited to 'meta-app-framework/recipes-core')
-rw-r--r--meta-app-framework/recipes-core/af-main/af-main_git.bb3
1 files changed, 0 insertions, 3 deletions
diff --git a/meta-app-framework/recipes-core/af-main/af-main_git.bb b/meta-app-framework/recipes-core/af-main/af-main_git.bb
index e5a183a31..917eaa414 100644
--- a/meta-app-framework/recipes-core/af-main/af-main_git.bb
+++ b/meta-app-framework/recipes-core/af-main/af-main_git.bb
@@ -85,9 +85,6 @@ do_install_append_class-target() {
ln -sf ../afm-system-daemon.service ${D}${systemd_system_unitdir}/multi-user.target.wants/afm-system-daemon.service
ln -sf ../afm-system-daemon.socket ${D}${systemd_system_unitdir}/sockets.target.wants/afm-system-daemon.socket
fi
-
- DEFAULT_WM_SHELL="${@bb.utils.contains('DISTRO_FEATURES', 'agl-compositor', 'xdg-shell-v6', 'ivi-shell', d)}"
- echo "QT_WAYLAND_SHELL_INTEGRATION=${DEFAULT_WM_SHELL}" > ${D}${afm_confdir}/unit.env.d/qt-shell
}
pkg_postinst_ontarget_${PN}() {
28 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 
/*
 * Copyright (C) 2018-2020 Konsulko Group
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <QDebug>

#include "callmessage.h"
#include "eventmessage.h"
#include "responsemessage.h"
#include "messagefactory.h"
#include "messageengine.h"
#include "messageenginefactory.h"
#include "bluetooth.h"
#include "bluetoothmodel.h"


Bluetooth::Bluetooth (QUrl &url, QQmlContext *context, QObject * parent) :
    QObject(parent),
    m_context(context)
{
    m_mloop = MessageEngineFactory::getInstance().getMessageEngine(url);
    m_bluetooth = new BluetoothModel();
    QObject::connect(m_mloop.get(), &MessageEngine::connected, this, &Bluetooth::onConnected);
    QObject::connect(m_mloop.get(), &MessageEngine::disconnected, this, &Bluetooth::onDisconnected);
    QObject::connect(m_mloop.get(), &MessageEngine::messageReceived, this, &Bluetooth::onMessageReceived);

    BluetoothModelFilter *m_model = new BluetoothModelFilter();
    m_model->setSourceModel(m_bluetooth);
    m_model->setFilterFixedString("true");
    context->setContextProperty("BluetoothPairedModel", m_model);

    m_model = new BluetoothModelFilter();
    m_model->setSourceModel(m_bluetooth);
    m_model->setFilterFixedString("false");
    context->setContextProperty("BluetoothDiscoveryModel", m_model);

    uuids.insert("a2dp", "0000110a-0000-1000-8000-00805f9b34fb");
    uuids.insert("avrcp", "0000110e-0000-1000-8000-00805f9b34fb");
    uuids.insert("hfp", "0000111f-0000-1000-8000-00805f9b34fb");
}

Bluetooth::~Bluetooth()
{
}

void Bluetooth::send_command(QString verb, QJsonObject parameter)
{
    std::unique_ptr<Message> msg = MessageFactory::getInstance().createOutboundMessage(MessageId::Call);
    if (!msg)
        return;

    CallMessage* btmsg = static_cast<CallMessage*>(msg.get());
    btmsg->createRequest("Bluetooth-Manager", verb, parameter);
    m_mloop->sendMessage(std::move(msg));
}

void Bluetooth::setPower(bool state)
{
    QJsonObject parameter;
    parameter.insert("powered", state ? "true" : "false");
    send_command("adapter_state", parameter);
}

void Bluetooth::setDiscoverable(bool state)
{
    QJsonObject parameter;
    parameter.insert("discoverable", state ? "true" : "false");
    send_command("adapter_state", parameter);

    m_discoverable = state;

    emit discoverableChanged();
}

void Bluetooth::discovery_command(bool state)
{
    QJsonObject parameter;
    parameter.insert("discovery", state ? "true" : "false");

    set_discovery_filter();

    send_command("adapter_state", parameter);
}

void Bluetooth::start_discovery()
{
    discovery_command(true);

    // temp workaround to list already discovered devices
    send_command("managed_objects", QJsonObject());
}

void Bluetooth::stop_discovery()
{
    discovery_command(false);
}

void Bluetooth::remove_device(QString device)
{
    QJsonObject parameter;
    parameter.insert("device", device);

    send_command("remove_device", parameter);
}

void Bluetooth::pair(QString device)
{
    QJsonObject parameter;
    parameter.insert("device", device);

    send_command("pair", parameter);
}

void Bluetooth::cancel_pair(QString device)
{
    send_command("cancel_pairing", QJsonObject());
}

void Bluetooth::connect(QString device, QString uuid)
{
    QJsonObject parameter;
    uuid = process_uuid(uuid);
    parameter.insert("device", device);
    parameter.insert("uuid", uuid);
    send_command("connect", parameter);
}

void Bluetooth::connect(QString device)
{
    QJsonObject parameter;
    parameter.insert("device", device);
    send_command("connect", parameter);
}

void Bluetooth::disconnect(QString device, QString uuid)
{
    QJsonObject parameter;
    uuid = process_uuid(uuid);
    parameter.insert("device", device);
    parameter.insert("uuid", uuid);
    send_command("disconnect", parameter);
}

void Bluetooth::disconnect(QString device)
{
    QJsonObject parameter;
    parameter.insert("device", device);
    send_command("disconnect", parameter);
}

void Bluetooth::send_confirmation(int pincode)
{
    QJsonObject parameter;
    parameter.insert("pincode", pincode);
    send_command("confirm_pairing", parameter);
}


void Bluetooth::set_discovery_filter()
{
    QStringListIterator eventIterator(uuids.values());
    QJsonObject parameter;
    QJsonArray array;

    while (eventIterator.hasNext())
        array.push_back(eventIterator.next());

    // send inital adapter state + discovery filter
    parameter.insert("filter", array);
    parameter.insert("transport", "bredr");
    send_command("adapter_state", parameter);
}

void Bluetooth::onConnected()
{
    QStringListIterator eventIterator(events);

    while (eventIterator.hasNext()) {
        QJsonObject parameter;
        parameter.insert("value", eventIterator.next());
        send_command("subscribe", parameter);
    }

    // send initial list
    send_command("managed_objects", QJsonObject());

    // get initial power state
    send_command("adapter_state", QJsonObject());
}

void Bluetooth::onDisconnected()
{
    QStringListIterator eventIterator(events);

    while (eventIterator.hasNext()) {
        QJsonObject parameter;
        parameter.insert("value", eventIterator.next());
        send_command("unsubscribe", parameter);
    }
}

void Bluetooth::populateDeviceList(QJsonObject data)
{
    QJsonArray devices = data.value("devices").toArray();

    m_bluetooth->removeAllDevices();

    for (auto value : devices) {
        BluetoothDevice *device = m_bluetooth->updateDeviceProperties(nullptr, value.toObject());
        m_bluetooth->addDevice(device);
    }
}

void Bluetooth::processDeviceChangesEvent(QJsonObject data)
{
    QString action = data.value("action").toString();
    QString id = data.value("device").toString();

    if (id.isEmpty())
        return;

    BluetoothDevice *device = m_bluetooth->getDevice(id);
    if (action == "removed") {
        if (device != nullptr)
            m_bluetooth->removeDevice(device);
	return;
    }

    BluetoothDevice *ndevice = m_bluetooth->updateDeviceProperties(device, data);
    if (ndevice == nullptr) {
        qDebug() << "bt - failed to create device object with id: " << id;
        return;
    }
    if (device == nullptr)  //device not previously in model
        m_bluetooth->addDevice(ndevice);
}

void Bluetooth::processAdapterChangesEvent(QJsonObject data)
{
    QString action = data.value("action").toString();
    if (action != "changed")
        return;

    QJsonObject properties = data.value("properties").toObject();
    if (!properties.contains("powered"))
        return;

    bool powered = properties.find("powered").value().toBool();
    if (!powered)
        m_bluetooth->removeAllDevices();

    if (m_power != powered) {
        m_power = powered;
        emit powerChanged(powered);
    }

    if (!m_power)
        m_discoverable = false;
}

void Bluetooth::onMessageReceived(std::shared_ptr<Message> msg)
{
    if (!msg)
        return;

    if (msg->isEvent()) {
        std::shared_ptr<EventMessage> emsg = std::static_pointer_cast<EventMessage>(msg);
        QString ename = emsg->eventName();
        QString eapi = emsg->eventApi();
        QJsonObject data = emsg->eventData();
        if (eapi != "Bluetooth-Manager")
            return;
        if (ename == "device_changes") {
            processDeviceChangesEvent(data);
        } else if (ename == "adapter_changes") {
            processAdapterChangesEvent(data);
        } else if (ename == "agent") {
            emit requestConfirmationEvent(data);
        }

    } else if (msg->isReply()) {
        std::shared_ptr<ResponseMessage> rmsg = std::static_pointer_cast<ResponseMessage>(msg);
        //get api name
        QString verb = rmsg->requestVerb();
        QJsonObject data = rmsg->replyData();
        if (verb == "managed_objects") {
            populateDeviceList(data);
        } else if (verb == "adapter_state") {
            bool powered = data.value("powered").toBool();
            if (m_power != powered) {
                m_power = powered;
                emit powerChanged(m_power);
            }
        }
    }
}