← Back to branch summary

~webapps/unity-firefox-extension/quantal

« back to all changes in this revision

Viewing changes to unity-firefox-extension/content/unity-api.js

  • Committer: Ken VanDine
  • Date: 2012-09-11 20:20:06 UTC
  • mfrom: (83.37.51)
  • Revision ID: ken.vandine@canonical.com-20120911202006-cnidpkmvipd1m901
Tags: 2.3-0quantal1
releasing version 2.3-0quantal1

Show diffs side-by-side

added added

removed removed

Lines of Context:
unity-firefox-extension/content/unity-api.js
16
16
function makeAPI(setTimeout, contextAddApplicationActions, init, toDataURL, log, uwa, unity, CallbackManager, acceptDataCb) {
17
17
    var api;
18
18
    function findName(func, prefix, obj) {
 
19
        var i;
19
20
        if (!prefix) {
20
21
            return findName(func, 'Unity.', api);
21
22
        }
22
 
        var keys = Object.keys(obj);
23
 
        for (var i = 0; i < keys.length; i++) {
 
23
        var keys = [];
 
24
        for (i in obj)
 
25
            keys.push(i);
 
26
        for (i = 0; i < keys.length; i++) {
24
27
            if (typeof(keys[i]) !== 'string') {
25
28
                continue;
26
29
            }
27
 
            var descr = Object.getOwnPropertyDescriptor(obj, keys[i]);
 
30
            var descr = { value: obj[keys[i]] };
28
31
            if (descr.value === func) {
29
32
                return prefix + keys[i];
30
33
            }
 
34
 
31
35
            if (descr.value instanceof Object) {
32
36
                var res = findName(func, prefix + keys[i] + '.', obj[keys[i]]);
 
37
 
33
38
                if (res)
34
39
                    return res;
35
40
            }
189
194
        contextAddApplicationActions(actions);
190
195
    }
191
196
    var firstAddStaticAction = true;
192
 
    api = {
 
197
 
 
198
    function MediaPlayer() {
 
199
    }
 
200
 
 
201
    MediaPlayer.prototype = {
 
202
        __exposedProps__: { init: 'r', onPlayPause: 'r', onPrevious: 'r', onNext: 'r',
 
203
                            setTrack: 'r', setCanGoNext: 'r', setCanGoPrevious: 'r',
 
204
                            setCanPlay: 'r', setCanPause: 'r', setPlaybackState: 'r',
 
205
                            getPlaybackState: 'r' },
 
206
 
 
207
        init: createArgumentsSanitaizer(uwa.music_player_init, [{ str: true }]),
 
208
 
 
209
        onPlayPause: createArgumentsSanitaizer(uwa.music_player_on_play_pause_callback,
 
210
                                               [{ type: Function, allowNull: true }, { dummy: true }]),
 
211
 
 
212
        onPrevious: createArgumentsSanitaizer(uwa.music_player_on_previous_callback,
 
213
                                              [{ type: Function, allowNull: true }, { dummy: true }]),
 
214
 
 
215
        onNext: createArgumentsSanitaizer(uwa.music_player_on_next_callback,
 
216
                                          [{ type: Function, allowNull: true }, { dummy: true }]),
 
217
 
 
218
        setTrack: createArgumentsSanitaizer(uwa.music_player_set_track,
 
219
                                            [{ obj: { artist: { str: true, place: 0, allowNull: true },
 
220
                                                      album: { str: true, place: 1, allowNull: true },
 
221
                                                      title: { str: true, place: 2 },
 
222
                                                      artLocation: { str: true, place: 3, allowNull: true } } }]),
 
223
 
 
224
        setCanGoNext: createArgumentsSanitaizer(uwa.music_player_set_can_go_next, [{ number: true }]),
 
225
 
 
226
        setCanGoPrevious: createArgumentsSanitaizer(uwa.music_player_set_can_go_previous, [{ number: true }]),
 
227
 
 
228
        setCanPlay: createArgumentsSanitaizer(uwa.music_player_set_can_play, [{ number: true }]),
 
229
 
 
230
        setCanPause: createArgumentsSanitaizer(uwa.music_player_set_can_pause, [{ number: true }]),
 
231
 
 
232
        setPlaybackState: createArgumentsSanitaizer(uwa.music_player_set_playback_state, [{ number: true }]),
 
233
 
 
234
        getPlaybackState: createArgumentsSanitaizer(null
 
235
                                                    , [{ type: Function }]
 
236
                                                    , function (context, callback) {
 
237
                                                        if (callback) {
 
238
                                                            callback (uwa.music_player_get_playback_state(context));
 
239
                                                        }
 
240
                                                    }),
 
241
 
 
242
        PlaybackState: {PLAYING: 0, PAUSED:1}
 
243
    };
 
244
 
 
245
    function MessagingIndicator() {
 
246
    }
 
247
 
 
248
    MessagingIndicator.prototype = {
 
249
        __exposedProps__: { addAction: 'r', showIndicator: 'r',
 
250
                            clearIndicator: 'r', clearIndicators: 'r' },
 
251
 
 
252
        addAction: createArgumentsSanitaizer(uwa.indicator_add_action,
 
253
                                             [{ str: true }, { type: Function, argAsCallbackId: 0 }, { dummy: true }]),
 
254
        showIndicator: function(name, properties) {
 
255
            log('Unity.MessagingIndicator.showIndicator(' + stringifyArgs(arguments) + ')');
 
256
 
 
257
            if (unity.context == null) {return};
 
258
 
 
259
            checkString(name, false);
 
260
 
 
261
            uwa.indicator_show_indicator(unity.context, String(name));
 
262
            for (i in properties) {
 
263
                if (i == "time") {
 
264
                    uwa.indicator_set_property(unity.context, String(name), i, UnityMiscUtils.toISODate(properties[i]));
 
265
                }
 
266
                else if (i == "icon") {
 
267
                    uwa.indicator_set_property_icon(unity.context, String(name), i, String(properties[i]));
 
268
                }
 
269
                else if (i == "callback") {
 
270
                    var callback = CallbackManager.makeCallback(uwa.IndicatorCallbackType,
 
271
                                                                (function (propidx) {
 
272
                                                                    return function (context, user_data) {
 
273
                                                                        (properties[propidx])();
 
274
                                                                    };
 
275
                                                                })(i),
 
276
                                                                'Unity.MessagingIndicator.showIndicator', name);
 
277
 
 
278
                    uwa.indicator_set_callback(unity.context, String(name), callback, null);
 
279
                }
 
280
                else if (i == "count") {
 
281
                    uwa.indicator_set_property(unity.context, String(name), i, String(Number(properties[i])));
 
282
                }
 
283
                else {
 
284
                    uwa.indicator_set_property(unity.context, String(name), i, String(properties[i]));
 
285
                }
 
286
            }
 
287
        },
 
288
        clearIndicator: createArgumentsSanitaizer(uwa.indicator_clear_indicator, [{ str: true }]),
 
289
        clearIndicators: createArgumentsSanitaizer(uwa.indicator_clear_indicators, [], function () {CallbackManager.releaseCallback('Unity.MessagingIndicator.showIndicator');})
 
290
    };
 
291
 
 
292
    function Launcher() {
 
293
    }
 
294
    Launcher.prototype = {
 
295
        __exposedProps__: { 'setCount': 'r', clearCount: 'r',
 
296
                             setProgress: 'r', clearProgress: 'r', setUrgent: 'r',
 
297
                             addAction: 'r', removeAction: 'r', removeActions: 'r' },
 
298
 
 
299
        setCount: createArgumentsSanitaizer(uwa.launcher_set_count,
 
300
                                            [{ number: true }]),
 
301
        clearCount: createArgumentsSanitaizer(uwa.launcher_clear_count,
 
302
                                              []),
 
303
        setProgress: createArgumentsSanitaizer(uwa.launcher_set_progress,
 
304
                                               [{ number: true }]),
 
305
        clearProgress: createArgumentsSanitaizer(uwa.launcher_clear_progress,
 
306
                                                 []),
 
307
        setUrgent: createArgumentsSanitaizer(uwa.launcher_set_urgent,
 
308
                                             []),
 
309
        _addAction: createArgumentsSanitaizer(uwa.launcher_add_action,
 
310
                                              [{ str: true }, { type: Function, argAsCallbackId: 0 }, { dummy: true }]),
 
311
        _addStaticAction: createArgumentsSanitaizer(uwa.launcher_add_static_action,
 
312
                                                    [{ str: true }, { str: true }]),
 
313
        addAction: function (arg1, arg2) {
 
314
            if (typeof(arg2) === 'string') {
 
315
                if (firstAddStaticAction)
 
316
                    uwa.launcher_remove_static_actions(unity.context);
 
317
                firstAddStaticAction = false;
 
318
                this._addStaticAction(arg1, arg2);
 
319
            } else {
 
320
                this._addAction(arg1, arg2);
 
321
            }
 
322
        },
 
323
 
 
324
        removeAction: createArgumentsSanitaizer(uwa.launcher_remove_action,
 
325
                                                [{ str: true }]),
 
326
        removeActions: createArgumentsSanitaizer(uwa.launcher_remove_actions,
 
327
                                                 [], function () {CallbackManager.releaseCallback('Unity.Launcher.addAction');})
 
328
    };
 
329
 
 
330
    function Notification() {
 
331
    }
 
332
 
 
333
    Notification.prototype = {
 
334
        __exposedProps__: { 'showNotification': 'r' },
 
335
        showNotification: createArgumentsSanitaizer(uwa.notification_show_notification,
 
336
                                                    [{ str: true }, { str: true }, { str: true, allowNull: true }])
 
337
    };
 
338
 
 
339
    var Api = function () {}
 
340
    Api.prototype = {
 
341
        __exposedProps__: { 'init': 'r', 'acceptData': 'r',
 
342
                            'addAction': 'r', 'clearAction': 'r',
 
343
                            'clearActions': 'r', 'toDataURL': 'r',
 
344
                            'MediaPlayer': 'r', 'Notification': 'r',
 
345
                            'Launcher': 'r', 'MessagingIndicator': 'r' },
 
346
 
 
347
        Notification: new Notification(),
 
348
        Launcher: new Launcher(),
 
349
        MessagingIndicator: new MessagingIndicator(),
 
350
        MediaPlayer: new MediaPlayer(),
 
351
 
193
352
        init: function(props) {
194
353
            checkString(props.name, false);
195
354
            checkString(props.iconUrl, true);
224
383
            CallbackManager.releaseCallback('Unity.addAction');
225
384
        }),
226
385
 
227
 
        MediaPlayer: {
228
 
            init: createArgumentsSanitaizer(uwa.music_player_init, [{ str: true }]),
229
 
 
230
 
            onPlayPause: createArgumentsSanitaizer(uwa.music_player_on_play_pause_callback,
231
 
                                                   [{ type: Function, allowNull: true }, { dummy: true }]),
232
 
 
233
 
            onPrevious: createArgumentsSanitaizer(uwa.music_player_on_previous_callback,
234
 
                                                  [{ type: Function, allowNull: true }, { dummy: true }]),
235
 
 
236
 
            onNext: createArgumentsSanitaizer(uwa.music_player_on_next_callback,
237
 
                                              [{ type: Function, allowNull: true }, { dummy: true }]),
238
 
 
239
 
            setTrack: createArgumentsSanitaizer(uwa.music_player_set_track,
240
 
                                                [{ obj: { artist: { str: true, place: 0, allowNull: true },
241
 
                                                          album: { str: true, place: 1, allowNull: true },
242
 
                                                          title: { str: true, place: 2 },
243
 
                                                          artLocation: { str: true, place: 3, allowNull: true } } }]),
244
 
 
245
 
            setCanGoNext: createArgumentsSanitaizer(uwa.music_player_set_can_go_next, [{ number: true }]),
246
 
 
247
 
            setCanGoPrevious: createArgumentsSanitaizer(uwa.music_player_set_can_go_previous, [{ number: true }]),
248
 
 
249
 
            setCanPlay: createArgumentsSanitaizer(uwa.music_player_set_can_play, [{ number: true }]),
250
 
 
251
 
            setCanPause: createArgumentsSanitaizer(uwa.music_player_set_can_pause, [{ number: true }]),
252
 
 
253
 
            setPlaybackState: createArgumentsSanitaizer(uwa.music_player_set_playback_state, [{ number: true }]),
254
 
 
255
 
            getPlaybackState: createArgumentsSanitaizer(null
256
 
                                                        , [{ type: Function }]
257
 
                                                        , function (context, callback) {
258
 
                                                          if (callback) {
259
 
                                                            callback (uwa.music_player_get_playback_state(context));
260
 
                                                          }
261
 
                                                        }),
262
 
 
263
 
            PlaybackState: {PLAYING: 0, PAUSED:1}
264
 
        },
265
 
 
266
 
        Notification: {
267
 
            showNotification: createArgumentsSanitaizer(uwa.notification_show_notification,
268
 
                                                        [{ str: true }, { str: true }, { str: true, allowNull: true }])
269
 
        },
270
 
 
271
 
        Launcher: {
272
 
            setCount: createArgumentsSanitaizer(uwa.launcher_set_count,
273
 
                                                [{ number: true }]),
274
 
            clearCount: createArgumentsSanitaizer(uwa.launcher_clear_count,
275
 
                                                  []),
276
 
            setProgress: createArgumentsSanitaizer(uwa.launcher_set_progress,
277
 
                                                   [{ number: true }]),
278
 
            clearProgress: createArgumentsSanitaizer(uwa.launcher_clear_progress,
279
 
                                                     []),
280
 
            setUrgent: createArgumentsSanitaizer(uwa.launcher_set_urgent,
281
 
                                                 []),
282
 
            _addAction: createArgumentsSanitaizer(uwa.launcher_add_action,
283
 
                                                  [{ str: true }, { type: Function, argAsCallbackId: 0 }, { dummy: true }]),
284
 
            _addStaticAction: createArgumentsSanitaizer(uwa.launcher_add_static_action,
285
 
                                                        [{ str: true }, { str: true }]),
286
 
            addAction: function (arg1, arg2) {
287
 
                if (typeof(arg2) === 'string') {
288
 
                    if (firstAddStaticAction)
289
 
                        uwa.launcher_remove_static_actions(unity.context);
290
 
                    firstAddStaticAction = false;
291
 
                    this._addStaticAction(arg1, arg2);
292
 
                } else {
293
 
                    this._addAction(arg1, arg2);
294
 
                }
295
 
            },
296
 
 
297
 
            removeAction: createArgumentsSanitaizer(uwa.launcher_remove_action,
298
 
                                                 [{ str: true }]),
299
 
            removeActions: createArgumentsSanitaizer(uwa.launcher_remove_actions,
300
 
                                                 [], function () {CallbackManager.releaseCallback('Unity.Launcher.addAction');})
301
 
        },
302
 
 
303
 
        MessagingIndicator: {
304
 
            addAction: createArgumentsSanitaizer(uwa.indicator_add_action,
305
 
                                                 [{ str: true }, { type: Function, argAsCallbackId: 0 }, { dummy: true }]),
306
 
            showIndicator: function(name, properties) {
307
 
                log('Unity.MessagingIndicator.showIndicator(' + stringifyArgs(arguments) + ')');
308
 
 
309
 
                if (unity.context == null) {return};
310
 
 
311
 
                checkString(name, false);
312
 
 
313
 
                uwa.indicator_show_indicator(unity.context, String(name));
314
 
                for (i in properties) {
315
 
                    if (i == "time") {
316
 
                        uwa.indicator_set_property(unity.context, String(name), i, UnityMiscUtils.toISODate(properties[i]));
317
 
                    }
318
 
                    else if (i == "icon") {
319
 
                        uwa.indicator_set_property_icon(unity.context, String(name), i, String(properties[i]));
320
 
                    }
321
 
                    else if (i == "callback") {
322
 
                        var callback = CallbackManager.makeCallback(uwa.IndicatorCallbackType,
323
 
                                                                    (function (propidx) {
324
 
                                                                       return function (context, user_data) {
325
 
                                                                         (properties[propidx])();
326
 
                                                                       };
327
 
                                                                     })(i),
328
 
                                                                    'Unity.MessagingIndicator.showIndicator', name);
329
 
 
330
 
                        uwa.indicator_set_callback(unity.context, String(name), callback, null);
331
 
                    }
332
 
                    else if (i == "count") {
333
 
                        uwa.indicator_set_property(unity.context, String(name), i, String(Number(properties[i])));
334
 
                    }
335
 
                    else {
336
 
                        uwa.indicator_set_property(unity.context, String(name), i, String(properties[i]));
337
 
                    }
338
 
                }
339
 
            },
340
 
            clearIndicator: createArgumentsSanitaizer(uwa.indicator_clear_indicator, [{ str: true }]),
341
 
            clearIndicators: createArgumentsSanitaizer(uwa.indicator_clear_indicators, [], function () {CallbackManager.releaseCallback('Unity.MessagingIndicator.showIndicator');})
342
 
        },
343
 
 
344
386
        toDataURL: function (uri, callback, sx, sy, sw, sh) {
345
387
            toDataURL(uri, callback, sx, sy, sw, sh);
346
388
        }
347
389
    };
348
390
 
 
391
    api = new Api();
 
392
 
349
393
    return api;
350
394
}