← Back to branch summary

~thomas-voss/platform-api/add-package-config

« back to all changes in this revision

Viewing changes to src/mirclient/ubuntu_application_api_mirclient.cpp

  • Committer: Thomas Voß
  • Date: 2013-06-20 12:26:40 UTC
  • mfrom: (67.1.1 fix-cmake-setup)
  • Revision ID: thomas.voss@canonical.com-20130620122640-ytzwepxb9qiijzgq
[ Gerry Boland ]
* Add mir suport.
[ Robert Carr ]
* Add mir suport.
[ Ubuntu daily release ]
* Automatic snapshot from revision 69
[ Ricardo Mendoza ]
* Allow remote App Manager to take care of signalling processes.
[ Ubuntu daily release ]
* Automatic snapshot from revision 67

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mirclient/ubuntu_application_api_mirclient.cpp
 
1
/*
 
2
 * Copyright (C) 2013 Canonical Ltd
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify
 
5
 * it under the terms of the GNU Lesser General Public License version 3 as
 
6
 * published by the Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU Lesser General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU Lesser General Public License
 
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
 *
 
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
 
17
 */
 
18
 
 
19
#include "application_instance_mirclient_priv.h"
 
20
#include "window_properties_mirclient_priv.h"
 
21
#include "window_mirclient_priv.h"
 
22
 
 
23
#include "mircommon/application_id_mir_priv.h"
 
24
 
 
25
#include <ubuntu/application/lifecycle_delegate.h>
 
26
#include <ubuntu/application/ui/window.h>
 
27
#include <ubuntu/application/ui/options.h>
 
28
#include <ubuntu/application/ui/session.h>
 
29
#include <ubuntu/application/ui/clipboard.h>
 
30
#include <ubuntu/application/ui/display.h>
 
31
#include <ubuntu/application/sensors/accelerometer.h>
 
32
#include <ubuntu/application/sensors/proximity.h>
 
33
#include <ubuntu/application/sensors/light.h>
 
34
 
 
35
#include <mir_toolkit/mir_client_library.h>
 
36
 
 
37
#include <stdlib.h>
 
38
#include <assert.h>
 
39
#include <string.h>
 
40
 
 
41
namespace uam = ubuntu::application::mir;
 
42
namespace uamc = uam::client;
 
43
 
 
44
namespace
 
45
{
 
46
 
 
47
// We use a global instance as some platform-api functions, i.e. display_new_with_index
 
48
// do not supply dependencies, but a MirConnection is required for all queries.
 
49
static uamc::Instance*
 
50
global_mir_instance()
 
51
{
 
52
    // Obviously ref counting is whacky here...
 
53
    static uamc::Instance instance;
 
54
    instance.ref(); // We leak a reference, this object can't be destroyed
 
55
    return &instance;
 
56
}
 
57
 
 
58
// Display info
 
59
static MirDisplayInfo*
 
60
u_display_mir_display(UAUiDisplay *display)
 
61
{
 
62
    return static_cast<MirDisplayInfo*>(display);
 
63
}
 
64
 
 
65
static UAUiDisplay*
 
66
mir_display_u_display(MirDisplayInfo *display)
 
67
{
 
68
    return static_cast<UAUiDisplay*>(display);
 
69
}
 
70
 
 
71
};
 
72
 
 
73
extern "C"
 
74
{
 
75
 
 
76
// TODO<papi>: Eliminate global instance by adding Instance to some functions (i.e. display queries)
 
77
// TODO: We can't take ownership of description and options until we get rid of the global instance
 
78
// so we leak them.
 
79
UApplicationInstance* u_application_instance_new_from_description_with_options(UApplicationDescription* description, UApplicationOptions* options)
 
80
{
 
81
    auto instance = global_mir_instance();
 
82
 
 
83
    auto id = uam::Id::from_u_application_id(u_application_description_get_application_id(description));
 
84
    auto connect_suceeded = instance->connect(id->name);
 
85
    assert(connect_suceeded);
 
86
 
 
87
    return instance->as_u_application_instance();
 
88
}
 
89
 
 
90
void
 
91
u_application_instance_ref(UApplicationInstance *u_instance)
 
92
{
 
93
    auto instance = uamc::Instance::from_u_application_instance(u_instance);
 
94
    instance->ref();
 
95
}
 
96
    
 
97
void
 
98
u_application_instance_unref(UApplicationInstance *u_instance)
 
99
{
 
100
    auto instance = uamc::Instance::from_u_application_instance(u_instance);
 
101
    instance->unref();
 
102
}
 
103
    
 
104
void
 
105
u_application_instance_destroy(UApplicationInstance *u_instance)
 
106
{
 
107
    // TODO<papi>: What are the proper semantics here.
 
108
    u_application_instance_unref(u_instance);
 
109
}
 
110
    
 
111
void
 
112
u_application_instance_run(UApplicationInstance *instance)
 
113
{
 
114
    // TODO<papi>: What is this supposed to do? Seems to be no-op on hybris.
 
115
    (void) instance;
 
116
}
 
117
 
 
118
void ua_ui_set_clipboard_content(void* content, size_t content_size)
 
119
{
 
120
    // TODO<papi,mir>: Implement. We will need a MirConnection
 
121
    (void) content;
 
122
    (void) content_size;
 
123
}
 
124
 
 
125
void ua_ui_get_clipboard_content(void** out_content, size_t* out_content_size)
 
126
{
 
127
    // TODO<papi,mir>: Implement, see get_clipboard_comment.
 
128
    *out_content = NULL;
 
129
    *out_content_size = 0;
 
130
}
 
131
 
 
132
//
 
133
// TODO <papi>: We need to expose the EGLNativeDisplay somehow
 
134
//
 
135
 
 
136
// TODO <papi>: This function should take an application instance so we can eliminate the global mir instance.
 
137
// TODO <mir>: Perhaps this should be noop for Mir as there is no need to construct
 
138
// a display object, the connection already has everything we need, as it receives
 
139
// the display info at connect time.
 
140
UAUiDisplay* ua_ui_display_new_with_index(size_t index)
 
141
{
 
142
    // TODO<papi,mir>: What are the semantics of index. How should we use it?
 
143
    (void) index;
 
144
    auto instance = global_mir_instance();
 
145
 
 
146
    auto display = new MirDisplayInfo;
 
147
    mir_connection_get_display_info(instance->connection(), display);
 
148
 
 
149
    return mir_display_u_display(display);
 
150
}
 
151
 
 
152
void ua_ui_display_destroy(UAUiDisplay* display)
 
153
{
 
154
    auto mir_display = u_display_mir_display(display);
 
155
    delete mir_display;
 
156
}
 
157
 
 
158
uint32_t ua_ui_display_query_horizontal_res(UAUiDisplay* display)
 
159
{
 
160
    auto mir_display = u_display_mir_display(display);
 
161
 
 
162
    // TODO<mir>: Line up return types from mirclient
 
163
    return static_cast<uint32_t>(mir_display->width);
 
164
}
 
165
 
 
166
uint32_t ua_ui_display_query_vertical_res(UAUiDisplay* display)
 
167
{
 
168
    auto mir_display = u_display_mir_display(display);
 
169
 
 
170
    // TODO<mir>: Line up return types from mirclient
 
171
    return static_cast<uint32_t>(mir_display->height);
 
172
}
 
173
 
 
174
EGLNativeDisplayType ua_ui_display_get_native_type(UAUiDisplay* display)
 
175
{
 
176
    auto instance = global_mir_instance();
 
177
 
 
178
    // TODO<mir>: Careful with this cast
 
179
    return reinterpret_cast<EGLNativeDisplayType>(mir_connection_get_egl_native_display(instance->connection()));
 
180
}
 
181
 
 
182
UAUiWindowProperties* ua_ui_window_properties_new_for_normal_window()
 
183
{
 
184
    return (new uamc::WindowProperties)->as_u_window_properties();
 
185
}
 
186
 
 
187
void ua_ui_window_properties_destroy(UAUiWindowProperties* u_properties)
 
188
{
 
189
    auto properties = uamc::WindowProperties::from_u_window_properties(u_properties);
 
190
    delete properties;
 
191
}
 
192
 
 
193
void ua_ui_window_properties_set_titlen(UAUiWindowProperties* u_properties, const char* title, size_t title_length)
 
194
{
 
195
    auto properties = uamc::WindowProperties::from_u_window_properties(u_properties);
 
196
 
 
197
    properties->set_title(title, title_length);
 
198
}
 
199
 
 
200
const char* ua_ui_window_properties_get_title(UAUiWindowProperties* u_properties)
 
201
{
 
202
    auto properties = uamc::WindowProperties::from_u_window_properties(u_properties);
 
203
    return properties->surface_parameters().name;
 
204
}
 
205
 
 
206
void ua_ui_window_properties_set_role(UAUiWindowProperties* properties, UAUiWindowRole role)
 
207
{
 
208
    // TODO<papi>: Doesn't seem like this is meaningful for mirclient. Perhaps it should leave platform-api.
 
209
    (void) properties;
 
210
    (void) role;
 
211
}
 
212
 
 
213
void ua_ui_window_properties_set_input_cb_and_ctx(UAUiWindowProperties* u_properties, UAUiWindowInputEventCb cb, void* ctx)
 
214
{
 
215
    auto properties = uamc::WindowProperties::from_u_window_properties(u_properties);
 
216
    properties->set_input_cb_and_ctx(cb, ctx);
 
217
}
 
218
 
 
219
UAUiWindow* ua_ui_window_new_for_application_with_properties(UApplicationInstance* u_instance, UAUiWindowProperties* u_properties)
 
220
{
 
221
    auto instance = uamc::Instance::from_u_application_instance(u_instance);
 
222
    auto properties = uamc::WindowProperties::from_u_window_properties(u_properties);
 
223
 
 
224
    auto window = new uamc::Window(*instance, properties);
 
225
    return window->as_u_window();
 
226
}
 
227
 
 
228
void ua_ui_window_destroy(UAUiWindow* u_window)
 
229
{
 
230
    auto window = uamc::Window::from_u_window(u_window);
 
231
    delete window;
 
232
}
 
233
 
 
234
UStatus ua_ui_window_move(UAUiWindow* u_window, uint32_t x, uint32_t y)
 
235
{
 
236
    // TODO<papi,mir>: Implement. Assuming this should exist on mirclient?
 
237
    (void) u_window;
 
238
    (void) x;
 
239
    (void) y;
 
240
    return (UStatus) 0;
 
241
}
 
242
 
 
243
UStatus ua_ui_window_resize(UAUiWindow* u_window, uint32_t width, uint32_t height)
 
244
{
 
245
    // TODO<mir>: Implement
 
246
    (void) u_window;
 
247
    (void) width;
 
248
    (void) height;
 
249
    return (UStatus) 0;
 
250
}
 
251
 
 
252
UStatus ua_ui_window_hide(UAUiWindow* u_window)
 
253
{
 
254
    // TODO<mir>: Implement
 
255
    (void) u_window;
 
256
    return (UStatus) 0;
 
257
}
 
258
 
 
259
UStatus ua_ui_window_show(UAUiWindow* u_window)
 
260
{
 
261
    // TODO<mir>: Implement
 
262
    (void) u_window;
 
263
    return (UStatus) 0;
 
264
}
 
265
 
 
266
void ua_ui_window_request_fullscreen(UAUiWindow* u_window)
 
267
{
 
268
    // TODO<mir>: Implement
 
269
    (void) u_window;
 
270
}
 
271
 
 
272
EGLNativeWindowType ua_ui_window_get_native_type(UAUiWindow* u_window)
 
273
{
 
274
    auto window = uamc::Window::from_u_window(u_window);
 
275
    return window->get_native_type();
 
276
}
 
277
 
 
278
// TODO: Sensors
 
279
}