blob: fa84025478ff275851f63172e0c4f9cdda57dec4 (
plain)
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*******************************************************************************
* Copyright 2009-2016 Jörg Müller
*
* 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.
******************************************************************************/
#pragma once
/**
* @file DeviceManager.h
* @ingroup devices
* The DeviceManager class.
*/
#include "Audaspace.h"
#include <memory>
#include <vector>
#include <unordered_map>
#include <string>
AUD_NAMESPACE_BEGIN
class IDevice;
class IDeviceFactory;
class I3DDevice;
/**
* This class manages all device plugins and maintains a device if asked to do so.
*
* This enables applications to access their output device without having to carry
* it through the whole application.
*/
class AUD_API DeviceManager
{
private:
static std::unordered_map<std::string, std::shared_ptr<IDeviceFactory>> m_factories;
static std::shared_ptr<IDevice> m_device;
// delete copy constructor and operator=
DeviceManager(const DeviceManager&) = delete;
DeviceManager& operator=(const DeviceManager&) = delete;
DeviceManager() = delete;
public:
/**
* Registers a device factory.
*
* This method is mostly used by plugin developers to add their device implementation
* for general use by the library end users.
* @param name A representative name for the device.
* @param factory The factory that creates the device.
*/
static void registerDevice(std::string name, std::shared_ptr<IDeviceFactory> factory);
/**
* Returns the factory for a specific device.
* @param name The representative name of the device.
* @return The factory if it was found, or nullptr otherwise.
*/
static std::shared_ptr<IDeviceFactory> getDeviceFactory(std::string name);
/**
* Returns the default device based on the priorities of the registered factories.
* @return The default device or nullptr if no factory has been registered.
*/
static std::shared_ptr<IDeviceFactory> getDefaultDeviceFactory();
/**
* Sets a device that should be handled by the manager.
*
* If a device is currently being handled it will be released.
* @param device The device the manager should take care of.
*/
static void setDevice(std::shared_ptr<IDevice> device);
/**
* Opens a device which will then be handled by the manager.
*
* If a device is currently being handled it will be released.
* @param name The representative name of the device.
*/
static void openDevice(std::string name);
/**
* Opens the default device which will then be handled by the manager.
*
* The device to open is selected based on the priority of the registered factories.
* If a device is currently being handled it will be released.
*/
static void openDefaultDevice();
/**
* Releases the currently handled device.
*/
static void releaseDevice();
/**
* Returns the currently handled device.
* @return The handled device or nullptr if no device has been registered.
*/
static std::shared_ptr<IDevice> getDevice();
/**
* Returns the currently handled 3D device.
* @return The handled device or nullptr if no device has been registered
* or the registered device is not an I3DDevice.
*/
static std::shared_ptr<I3DDevice> get3DDevice();
/**
* Returns a list of available devices.
* @return A list of strings with the names of available devices.
*/
static std::vector<std::string> getAvailableDeviceNames();
};
AUD_NAMESPACE_END
|
