~aleteoryx/muditaos

muditaos/module-apps/apps-common/AudioOperations.cpp -rw-r--r-- 3.4 KiB
a405cad6 — Aleteoryx trim readme 6 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md

#include "AudioOperations.hpp"

#include <log/log.hpp>
#include <service-audio/AudioServiceAPI.hpp>
#include <service-audio/AudioServiceName.hpp>
#include <time/ScopedTime.hpp>
#include <purefs/filesystem_paths.hpp>
#include <service-audio/AudioMessage.hpp>

#include <filesystem>

namespace app
{
    AsyncAudioOperations::AsyncAudioOperations(ApplicationCommon *application)
        : app::AsyncCallbackReceiver{application}, application(application)
    {}

    bool AsyncAudioOperations::play(const std::string &filePath,
                                    const OnPlayCallback &callback,
                                    const audio::PlaybackType playbackType)
    {
        auto msg  = std::make_unique<AudioStartPlaybackRequest>(filePath, playbackType);
        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
        auto cb   = [callback](auto response) {
            auto result = dynamic_cast<AudioStartPlaybackResponse *>(response);
            if (result == nullptr) {
                return false;
            }
            if (callback) {
                callback(result->retCode, result->token);
            }
            return true;
        };
        task->execute(application, this, cb);
        return true;
    }

    bool AsyncAudioOperations::pause(const audio::Token &token, const OnPauseCallback &callback)
    {
        auto msg  = std::make_unique<AudioPauseRequest>(token);
        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
        auto cb   = [callback](auto response) {
            auto result = dynamic_cast<AudioPauseResponse *>(response);
            if (result == nullptr) {
                return false;
            }
            if (callback) {
                callback(result->retCode, result->token);
            }
            return true;
        };
        task->execute(application, this, cb);
        return true;
    }
    bool AsyncAudioOperations::resume(const audio::Token &token, const OnResumeCallback &callback)
    {
        auto msg  = std::make_unique<AudioResumeRequest>(token);
        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
        auto cb   = [callback](auto response) {
            auto result = dynamic_cast<AudioResumeResponse *>(response);
            if (result == nullptr) {
                return false;
            }
            if (callback) {
                callback(result->retCode, result->token);
            }
            return true;
        };
        task->execute(application, this, cb);
        return true;
    }
    bool AsyncAudioOperations::stop(const audio::Token &token, const OnStopCallback &callback)
    {
        auto msg  = std::make_unique<AudioStopRequest>(token);
        auto task = app::AsyncRequest::createFromMessage(std::move(msg), service::name::audio);
        auto cb   = [callback](auto response) {
            auto result = dynamic_cast<AudioStopResponse *>(response);
            if (result == nullptr) {
                return false;
            }
            if (callback) {
                callback(result->retCode, result->token);
            }
            return true;
        };
        task->execute(application, this, cb);
        return true;
    }

} // namespace app