~ubuntu-branches/ubuntu/wily/unity-webapps-qml/wily-proposed
» Revision
34
: src/Ubuntu/UnityWebApps/UnityWebAppsBackendComponents.js
« back to all changes in this revision
Viewing changes to src/Ubuntu/UnityWebApps/UnityWebAppsBackendComponents.js
- browse files at revision 34
- compare with another revision
- download diff
- download tarball
- view history from revision 34
- Committer: Package Import Robot
- Author(s): Ubuntu daily release, Ubuntu daily release, Alexandre Abreu
- Date: 2014-05-14 22:31:22 UTC
- mfrom: (1.1.30)
- Revision ID: package-import@ubuntu.com-20140514223122-ln3ei1hz5je1tkc6
Tags: 0.1+14.10.20140514.2-0ubuntu1
[ Ubuntu daily release ]
* New rebuild forced
[ Alexandre Abreu ]
* Cleanup the structure of the QML bindings to make it clearer. No
Changes in functionality all features are still working & same, This
is an updated version of: https://code.launchpad.net/~abreu-
alexandre/unity-webapps-qml/restructure-cleanup-bindings-qml-
structure/+merge/208148 with the latest changes that got in in
between (LP: #1288801)
* Simplifies the manifest.json handling in some instances. More
precisely when one is using a custom model search path for the
webapp lookup, some restrictions are being put on what is expected
to be found in the folder among which: a common/ subfolder (even if
the webapp doesnt require one),. one or more unity-webapps-* folders
with manifest.json & *.user.js files in it,. More over the manifest
files do require user scripts to be defined. This imposes a set of
constraints over a given webapp that simply wants to use the
container (w/o js injection). This simplifies it an allows one to
define a manifest.json file (still with some required elements, but
a smaller set), directly in the model search path. E.g. something
like: { "name": "MyWebApp", "homepage":
"http://www.bbc.co.uk/news/", "domain": "bbc.co.uk",
"includes": [] } will do, or to avoid any confusion w/ the click
manifest.json file, one also searches for a webapp-properties.json
w/ the same content as above.
* New rebuild forced
[ Alexandre Abreu ]
* Cleanup the structure of the QML bindings to make it clearer. No
Changes in functionality all features are still working & same, This
is an updated version of: https://code.launchpad.net/~abreu-
alexandre/unity-webapps-qml/restructure-cleanup-bindings-qml-
structure/+merge/208148 with the latest changes that got in in
between (LP: #1288801)
* Simplifies the manifest.json handling in some instances. More
precisely when one is using a custom model search path for the
webapp lookup, some restrictions are being put on what is expected
to be found in the folder among which: a common/ subfolder (even if
the webapp doesnt require one),. one or more unity-webapps-* folders
with manifest.json & *.user.js files in it,. More over the manifest
files do require user scripts to be defined. This imposes a set of
constraints over a given webapp that simply wants to use the
container (w/o js injection). This simplifies it an allows one to
define a manifest.json file (still with some required elements, but
a smaller set), directly in the model search path. E.g. something
like: { "name": "MyWebApp", "homepage":
"http://www.bbc.co.uk/news/", "domain": "bbc.co.uk",
"includes": [] } will do, or to avoid any confusion w/ the click
manifest.json file, one also searches for a webapp-properties.json
w/ the same content as above.
- tests/unit/test_plugin/data/simple-install
- tests/unit/test_plugin/data/simple-install-webapp-properties-file
- files modified:
- debian/changelog
added
removed
src/Ubuntu/UnityWebApps/UnityWebAppsBackendComponents.js
16
16
* along with this program. If not, see <http://www.gnu.org/licenses/>.
17
17
*/
18
18
19
.import Ubuntu.Content 0.1 as ContentHubBridge
20
.import Ubuntu.Components 0.1 as ComponentsBridge
21
22
19
var _backends = {};
23
20
24
21
function __set(id, component) {
415
412
};
416
413
417
414
418
419
420
/**
421
*
422
* Online Accounts API backend binding
423
*
424
*/
425
function createOnlineAccountsApi(backendDelegate) {
426
var PLUGIN_URI = 'Ubuntu.OnlineAccounts';
427
var VERSION = 0.1;
428
429
function Account(account, objectid) {
430
var id = objectid;
431
if ( ! id) {
432
id = backendDelegate.storeQmlObject(transfer,
433
PLUGIN_URI, VERSION, 'Account');
434
}
435
this._id = id;
436
this._object = account;
437
};
438
Account.prototype = {
439
_validate: function() {
440
if (! this._object)
441
throw new TypeError("Invalid object null");
442
},
443
444
destroy: function() {
445
if (! this._object)
446
return;
447
this._object.destroy();
448
backendDelegate.deleteId(this._id);
449
},
450
451
// object methods
452
serialize: function() {
453
var self = this;
454
return {
455
type: 'object-proxy',
456
apiid: 'OnlineAccounts',
457
objecttype: 'Account',
458
objectid: self._id,
459
460
// serialize immutable values
461
content: {
462
enabled: self._object.enabled,
463
provider: self._object.provider,
464
displayName: self._object.displayName,
465
accountId: self._object.accountId,
466
}
467
}
468
},
469
470
// properties
471
472
// immutable
473
enabled: function(callback) {
474
this._validate();
475
callback(this._object.enabled);
476
},
477
478
// immutable
479
provider: function(callback) {
480
this._validate();
481
callback(this._object.provider);
482
},
483
484
// immutable
485
displayName: function(callback) {
486
this._validate();
487
callback(this._object.displayName);
488
},
489
490
// immutable
491
accountId: function(callback) {
492
this._validate();
493
callback(this._object.accountId);
494
},
495
496
// method
497
498
updateDisplayName: function(displayName) {
499
this._validate();
500
this._object.updateDisplayName(displayName);
501
},
502
503
updateEnabled: function(enabled) {
504
this._validate();
505
this._object.updateEnabled(enabled);
506
},
507
508
remove: function(enabled) {
509
this._validate();
510
this._object.remove();
511
},
512
};
513
514
function AccountService(service, objectid) {
515
var id = objectid;
516
if ( ! service) {
517
var result = backendDelegate.createQmlObject(
518
PLUGIN_URI, VERSION, 'AccountService');
519
id = result.id;
520
service = result.object;
521
}
522
if ( ! id) {
523
id = backendDelegate.storeQmlObject(service,
524
PLUGIN_URI, VERSION, 'AccountService');
525
}
526
this._id = id;
527
this._object = service;
528
};
529
AccountService.prototype = {
530
_validate: function() {
531
if (! this._object)
532
throw new TypeError("Invalid object null");
533
},
534
535
destroy: function() {
536
if (! this._object)
537
return;
538
this._object.destroy();
539
backendDelegate.deleteId(this._id);
540
},
541
542
// object methods
543
serialize: function() {
544
var self = this;
545
return {
546
type: 'object-proxy',
547
apiid: 'OnlineAccounts',
548
objecttype: 'AccountService',
549
objectid: self._id,
550
551
// serialize immutable values
552
553
content: {
554
accountId: self._object.accountId,
555
enabled: self._object.enabled,
556
serviceEnabled: self._object.serviceEnabled,
557
displayName: self._object.displayName,
558
provider: self.internal.getProvider(self),
559
service: self.internal.getService(self),
560
},
561
}
562
},
563
564
// properties
565
566
autoSync: function(callback) {
567
this._validate();
568
callback(this._object.autoSync);
569
},
570
setAutoSync: function(autoSync, callback) {
571
this._validate();
572
this._object.autoSync = autoSync;
573
if (callback)
574
callback();
575
},
576
577
// immutable
578
accountId: function(callback) {
579
this._validate();
580
callback(this._object.accountId);
581
},
582
583
// immutable
584
enabled: function(callback) {
585
this._validate();
586
callback(this._object.enabled);
587
},
588
589
// immutable
590
serviceEnabled: function(callback) {
591
this._validate();
592
callback(this._object.serviceEnabled);
593
},
594
595
// immutable
596
displayName: function(callback) {
597
this._validate();
598
callback(this._object.displayName);
599
},
600
601
// immutable
602
provider: function(callback) {
603
this._validate();
604
callback(this.internal.getProvider(this));
605
},
606
607
// immutable
608
service: function(callback) {
609
this._validate();
610
callback(this.internal.getService(this));
611
},
612
613
objectHandle: function(callback) {
614
this._validate();
615
callback(this._object.objectHandle);
616
},
617
setObjectHandle: function(objectHandle) {
618
this._validate();
619
this._object.objectHandle = objectHandle;
620
},
621
622
// methods
623
authenticate: function(callback) {
624
this._validate();
625
626
var onAuthenticated;
627
var onAuthenticationError;
628
629
var self = this;
630
onAuthenticated = function(reply) {
631
callback({error: null,
632
authenticated: true,
633
data: reply});
634
635
self._object.onAuthenticated.disconnect(onAuthenticated);
636
self._object.onAuthenticationError.disconnect(onAuthenticationError);
637
};
638
onAuthenticationError = function(error){
639
callback({error: error.message,
640
authenticated: false,
641
data: null,
642
accountId: null});
643
644
self._object.onAuthenticated.disconnect(onAuthenticated);
645
self._object.onAuthenticationError.disconnect(onAuthenticationError);
646
};
647
648
this._object.onAuthenticated.connect(onAuthenticated);
649
this._object.onAuthenticationError.connect(onAuthenticationError);
650
651
this._object.authenticate(null);
652
},
653
654
// Internal
655
656
internal: {
657
getService: function(self) {
658
return {
659
id: self._object.service.id,
660
displayName: self._object.service.displayName,
661
iconName: self._object.service.iconName,
662
};
663
},
664
getProvider: function(self) {
665
return {
666
id: self._object.provider.id,
667
displayName: self._object.provider.displayName,
668
iconName: self._object.provider.iconName,
669
};
670
}
671
}
672
};
673
674
675
function Manager() {
676
var result = backendDelegate.createQmlObject(
677
PLUGIN_URI, VERSION, 'Manager');
678
this._id = result.id;
679
this._object = result.object;
680
};
681
Manager.prototype = {
682
_validate: function() {
683
if (! this._object)
684
throw new TypeError("Invalid object null");
685
},
686
687
destroy: function() {
688
if (! this._object)
689
return;
690
this._object.destroy();
691
backendDelegate.deleteId(this._id);
692
},
693
694
// object methods
695
serialize: function() {
696
return {
697
type: 'object-proxy',
698
apiid: 'OnlineAccounts',
699
objecttype: 'Manager',
700
objectid: this._id,
701
}
702
},
703
704
// methods
705
createAccount: function(providerName, callback) {
706
this._validate();
707
var account = new Account(this._object.createAccount(providerName));
708
callback(account.serialize());
709
},
710
loadAccount: function(id, callback) {
711
this._validate();
712
var account = new Account(this._object.loadAccount(id));
713
callback(account.serialize());
714
},
715
716
internal: {
717
loadAccount: function(self, id) {
718
return new Account(self._object.loadAccount(id));
719
},
720
},
721
};
722
723
724
function ProviderModel() {
725
var result = backendDelegate.createQmlObject(
726
PLUGIN_URI, VERSION, 'ProviderModel');
727
this._id = result.id;
728
this._object = result.object;
729
730
this._modelAdaptor = backendDelegate.createModelAdaptorFor(this._object);
731
this._roles = this._modelAdaptor.roles();
732
};
733
ProviderModel.prototype = {
734
_validate: function() {
735
if (! this._object)
736
throw new TypeError("Invalid object null");
737
},
738
739
destroy: function() {
740
if (! this._object)
741
return;
742
this._object.destroy();
743
this._modelAdaptor.destroy();
744
backendDelegate.deleteId(this._id);
745
},
746
747
// object methods
748
serialize: function() {
749
this._validate();
750
return {
751
type: 'object-proxy',
752
apiid: 'OnlineAccounts',
753
objecttype: 'ProviderModel',
754
objectid: this._id,
755
}
756
},
757
758
// properties
759
760
applicationId: function(callback) {
761
this._validate();
762
callback(this._object.applicationId);
763
},
764
setApplicationId: function(applicationId, callback) {
765
this._validate();
766
this._object.applicationId = applicationId;
767
if (callback)
768
callback();
769
},
770
771
// QAbtractListModel prototype
772
count: function(callback) {
773
this._validate();
774
if (this._modelAdaptor) {
775
return -1;
776
}
777
callback(this._modelAdaptor.rowCount());
778
},
779
780
at: function(idx, callback) {
781
this._validate();
782
if (idx >= this.proxy.count || ! this._modelAdaptor) {
783
callback(null);
784
return;
785
}
786
787
var result = {};
788
for (var role in this._roles) {
789
result[role] = this._modelAdaptor.itemAt(idx, role);
790
}
791
callback(result);
792
}
793
};
794
795
function AccountServiceModel(filterParams) {
796
var result = backendDelegate.createQmlObject(
797
PLUGIN_URI, VERSION, 'AccountServiceModel', filterParams);
798
this._id = result.id;
799
this._object = result.object;
800
801
this._modelAdaptor = backendDelegate.createModelAdaptorFor(this._object);
802
this._roles = this._modelAdaptor.roles();
803
804
// quickly filter out roles that are "tricky"
805
if (this._roles.indexOf('accountServiceHandle') !== -1) {
806
this._roles.splice(this._roles.indexOf('accountServiceHandle'), 1);
807
}
808
if (this._roles.indexOf('accountHandle') !== -1) {
809
this._roles.splice(this._roles.indexOf('accountHandle'), 1);
810
}
811
};
812
AccountServiceModel.prototype = {
813
_validate: function() {
814
if (! this._object)
815
throw new TypeError("Invalid object null");
816
},
817
818
destroy: function() {
819
if (! this._object)
820
return;
821
this._object.destroy();
822
this._modelAdaptor.destroy();
823
backendDelegate.deleteId(this._id);
824
},
825
826
// properties
827
count: function(callback) {
828
this._validate();
829
callback(this._object.count);
830
},
831
832
service: function(callback) {
833
this._validate();
834
callback(this._object.service);
835
},
836
setService: function(service, callback) {
837
this._validate();
838
this._object.service = service;
839
if (callback)
840
callback();
841
},
842
843
provider: function(callback) {
844
this._validate();
845
callback(this._object.provider);
846
},
847
setProvider: function(provider, callback) {
848
this._validate();
849
this._object.provider = provider;
850
if (callback)
851
callback();
852
},
853
854
serviceType: function(callback) {
855
this._validate();
856
callback(this._object.serviceType);
857
},
858
setServiceType: function(serviceType, callback) {
859
this._validate();
860
this._object.serviceType = serviceType;
861
if (callback)
862
callback();
863
},
864
865
includeDisabled: function(callback) {
866
this._validate();
867
callback(this._object.includeDisabled);
868
},
869
setIncludeDisabled: function(includeDisabled, callback) {
870
this._validate();
871
this._object.includeDisabled = includeDisabled;
872
if (callback)
873
callback();
874
},
875
876
accountId: function(callback) {
877
this._validate();
878
callback(this._object.accountId);
879
},
880
setAccountId: function(accountId, callback) {
881
this._validate();
882
this._object.accountId = accountId;
883
if (callback)
884
callback();
885
},
886
887
// QAbtractListModel prototype
888
count: function(callback) {
889
if (this._modelAdaptor) {
890
callback(-1);
891
}
892
callback(this._modelAdaptor.rowCount());
893
},
894
895
at: function(idx, callback) {
896
var count = this._modelAdaptor.rowCount();
897
if (idx >= count || ! this._modelAdaptor) {
898
callback(null);
899
return;
900
}
901
var result = {};
902
for (var role in this._roles) {
903
result[role] = this._modelAdaptor.itemAt(idx, role);
904
}
905
callback(result);
906
},
907
908
// Internal bits, not part of the API (especially no async)
909
910
internal: {
911
912
// special case for an object wrapper
913
accountServiceAtIndex: function(self, idx) {
914
self._validate();
915
916
var accountServiceHandle = self._modelAdaptor.itemAt(idx, "accountServiceHandle");
917
918
if (accountServiceHandle != null) {
919
var accountService = new AccountService();
920
accountService.setObjectHandle(accountServiceHandle);
921
return accountService;
922
}
923
924
return null;
925
},
926
927
itemAt: function(self, idx, role) {
928
self._validate();
929
return self._modelAdaptor.itemAt(idx, role);
930
},
931
932
count: function(self) {
933
return self._modelAdaptor ?
934
self._modelAdaptor.rowCount()
935
: -1;
936
},
937
938
includeDisabled: function(self) {
939
return self._object.includeDisabled;
940
},
941
}
942
};
943
944
function _constructorFromName(className) {
945
var constructorPerName = {
946
"AccountServiceModel": AccountServiceModel,
947
"Account": Account,
948
"ProviderModel": ProviderModel,
949
"Manager": Manager,
950
"AccountService": AccountService
951
};
952
return className in constructorPerName
953
? constructorPerName[className]
954
: null;
955
};
956
957
return {
958
createAccountServiceModel: function(callback) {
959
var service = new AccountServiceModel();
960
callback(service.serialize());
961
},
962
createManager: function(callback) {
963
var manager = new Manager();
964
callback(manager.serialize());
965
},
966
createProviderModel: function(callback) {
967
var provider = new ProviderModel();
968
callback(provider.serialize());
969
},
970
971
// api
972
getAccountsInfoFor: function(service, provider, callback) {
973
var serviceModel = new AccountServiceModel({'service': service, 'provider': provider});
974
975
var count = serviceModel.internal.count(serviceModel);
976
var accountsInfo = []
977
for (var i = 0; i < count; ++i) {
978
var displayName = serviceModel.internal.itemAt(serviceModel, i, "displayName");
979
var accountId = serviceModel.internal.itemAt(serviceModel, i, "accountId");
980
var providerName = serviceModel.internal.itemAt(serviceModel, i, "providerName");
981
var serviceName = serviceModel.internal.itemAt(serviceModel, i, "serviceName");
982
var enabled = serviceModel.internal.itemAt(serviceModel, i, "enabled");
983
984
accountsInfo.push({displayName: displayName
985
, accountId: accountId
986
, providerName: providerName
987
, serviceName: serviceName
988
, enabled: enabled
989
});
990
}
991
serviceModel.destroy();
992
993
callback(accountsInfo);
994
},
995
996
getAccounts: function(filters, callback) {
997
var serviceModel = new AccountServiceModel(filters);
998
var count = serviceModel.internal.count(serviceModel);
999
var accounts = []
1000
for (var i = 0; i < count; ++i) {
1001
var service = serviceModel.internal.accountServiceAtIndex(serviceModel, i);
1002
if (service) {
1003
var s = service.serialize();
1004
console.debug(JSON.stringify(s.content))
1005
accounts.push(s);
1006
}
1007
}
1008
callback(accounts);
1009
},
1010
1011
getAccountById: function(accountId, callback) {
1012
var manager = new Manager();
1013
var account = manager.internal.loadAccount(manager, accountId);
1014
manager.destroy();
1015
callback(account.serialize());
1016
},
1017
1018
getAccessTokenFor: function(serviceName, providerName, accountId, callback) {
1019
var serviceModel = new AccountServiceModel();
1020
1021
if (serviceName)
1022
serviceModel.setService(serviceName);
1023
if (providerName)
1024
serviceModel.setProvider(providerName);
1025
if (accountId)
1026
serviceModel.setAccountId(accountId);
1027
1028
var count = serviceModel.internal.count(serviceModel);
1029
if (count > 0) {
1030
var accountIdx = 0;
1031
if (count > 1) {
1032
console.debug("More than one account with id: " + accountId);
1033
}
1034
var onAuthenticated = function(results) {
1035
serviceModel.destroy();
1036
callback(results);
1037
};
1038
serviceModel.internal
1039
.accountServiceAtIndex(serviceModel, accountIdx)
1040
.authenticate(onAuthenticated);
1041
}
1042
else {
1043
serviceModel.destroy();
1044
callback({error: "No account found"});
1045
}
1046
},
1047
1048
// Internal
1049
1050
dispatchToObject: function(infos) {
1051
var args = infos.args;
1052
var callback = infos.callback;
1053
var method_name = infos.method_name;
1054
var objectid = infos.objectid;
1055
var class_name = infos.class_name;
1056
1057
if (callback)
1058
args.push(callback);
1059
1060
var o = backendDelegate.objectFromId(objectid);
1061
if (o == null) {
1062
console.debug('Cannot dispatch to unknown object: ' + objectid);
1063
return;
1064
}
1065
1066
var Constructor = _constructorFromName(class_name);
1067
1068
var instance = new Constructor(o, objectid);
1069
1070
instance[method_name].apply(instance, args);
1071
}
1072
};
1073
}
1074
1075
1076
/**
1077
*
1078
* Alarm API backend binding
1079
*
1080
*/
1081
function createAlarmApi(backendDelegate) {
1082
var PLUGIN_URI = 'Ubuntu.Components';
1083
var VERSION = 0.1;
1084
1085
function _nameToAlarmType(name) {
1086
var alarmTypePerName = {
1087
"OneTime": ComponentsBridge.Alarm.OneTime,
1088
"Repeating": ComponentsBridge.Alarm.Repeating,
1089
};
1090
return name in alarmTypePerName ?
1091
alarmTypePerName[name]
1092
: ComponentsBridge.Alarm.OneTime;
1093
};
1094
function _alarmTypeToName(type) {
1095
if (type === ComponentsBridge.Alarm.OneTime)
1096
return "OneTime";
1097
else if (type === ComponentsBridge.Alarm.Repeating)
1098
return "Repeating";
1099
return ;
1100
};
1101
1102
function Alarm(alarm, objectid) {
1103
var id = objectid;
1104
if ( ! alarm) {
1105
var result = backendDelegate.createQmlObject(
1106
PLUGIN_URI, VERSION, 'Alarm');
1107
id = result.id;
1108
alarm = result.object;
1109
}
1110
if ( ! id) {
1111
id = backendDelegate.storeQmlObject(alarm,
1112
PLUGIN_URI, VERSION, 'Account');
1113
}
1114
1115
this._id = id;
1116
this._object = alarm;
1117
};
1118
Alarm.prototype = {
1119
_validate: function() {
1120
if (! this._object)
1121
throw new TypeError("Invalid object null");
1122
},
1123
1124
destroy: function() {
1125
if (! this._object)
1126
return;
1127
this._object.destroy();
1128
backendDelegate.deleteId(this._id);
1129
},
1130
1131
// object methods
1132
serialize: function() {
1133
return {
1134
type: 'object-proxy',
1135
apiid: 'Alarm',
1136
objecttype: 'Alarm',
1137
objectid: this._id,
1138
}
1139
},
1140
1141
// methods
1142
cancel: function() {
1143
this._validate();
1144
this._object.cancel();
1145
},
1146
reset: function() {
1147
this._validate();
1148
this._object.reset();
1149
},
1150
save: function() {
1151
this._validate();
1152
this._object.save();
1153
},
1154
1155
1156
// properties
1157
error: function(callback) {
1158
this._validate();
1159
callback(this._object.error);
1160
},
1161
1162
date: function(callback) {
1163
this._validate();
1164
callback(this._object.date.getTime());
1165
},
1166
setDate: function(date, callback) {
1167
this._validate();
1168
var _date = new Date();
1169
_date.setTime(parseInt(date));
1170
this._object.date = _date;
1171
if (callback && typeof(callback) === 'function')
1172
callback();
1173
},
1174
1175
daysOfWeek: function(callback) {
1176
this._validate();
1177
callback(this._object.daysOfWeek);
1178
},
1179
setDaysOfWeek: function(daysOfWeek, callback) {
1180
this._validate();
1181
this._object.daysOfWeek = daysOfWeek;
1182
if (callback && typeof(callback) === 'function')
1183
callback();
1184
},
1185
1186
enabled: function(callback) {
1187
this._validate();
1188
callback(this._object.enabled);
1189
},
1190
setEnabled: function(enabled, callback) {
1191
this._validate();
1192
this._object.enabled = enabled;
1193
if (callback && typeof(callback) === 'function')
1194
callback();
1195
},
1196
1197
message: function(callback) {
1198
this._validate();
1199
callback(this._object.message);
1200
},
1201
setMessage: function(message, callback) {
1202
this._validate();
1203
this._object.message = message;
1204
if (callback && typeof(callback) === 'function')
1205
callback();
1206
},
1207
1208
sound: function(callback) {
1209
this._validate();
1210
callback(this._object.sound);
1211
},
1212
setSound: function(sound, callback) {
1213
this._validate();
1214
this._object.sound = sound;
1215
if (callback && typeof(callback) === 'function')
1216
callback();
1217
},
1218
1219
status: function(callback) {
1220
this._validate();
1221
callback(this._object.status.toString());
1222
},
1223
1224
type: function(callback) {
1225
this._validate();
1226
callback(_alarmTypeToName(this._object.type));
1227
},
1228
setType: function(type, callback) {
1229
this._validate();
1230
this._object.type = _nameToAlarmType(type);
1231
if (callback && typeof(callback) === 'function')
1232
callback();
1233
},
1234
1235
// internal
1236
1237
internal: {
1238
error: function(self) {
1239
return self._object.error;
1240
}
1241
}
1242
};
1243
1244
function _constructorFromName(className) {
1245
var constructorPerName = {
1246
"Alarm": Alarm,
1247
};
1248
return className in constructorPerName
1249
? constructorPerName[className]
1250
: null;
1251
}
1252
1253
return {
1254
createAlarm: function(callback) {
1255
console.log('createAlarm')
1256
var alarm = new Alarm();
1257
callback(alarm.serialize());
1258
},
1259
1260
createAndSaveAlarmFor: function(date, type, daysOfWeek, message, callback) {
1261
var alarm = new Alarm();
1262
1263
alarm.setDate(date);
1264
alarm.setMessage(message);
1265
alarm.setType(_nameToAlarmType(type));
1266
alarm.setDaysOfWeek(daysOfWeek);
1267
alarm.save();
1268
1269
if (callback && typeof(callback) === 'function')
1270
callback(alarm.internal.error(alarm));
1271
1272
alarm.destroy();
1273
},
1274
1275
1276
// Internal
1277
1278
dispatchToObject: function(infos) {
1279
var args = infos.args;
1280
var callback = infos.callback;
1281
var method_name = infos.method_name;
1282
var objectid = infos.objectid;
1283
var class_name = infos.class_name;
1284
1285
if (callback)
1286
args.push(callback);
1287
1288
var o = backendDelegate.objectFromId(objectid);
1289
if (o == null) {
1290
console.debug('Cannot dispatch to unknown object: ' + objectid);
1291
return;
1292
}
1293
1294
var Constructor = _constructorFromName(class_name);
1295
1296
var instance = new Constructor(o, objectid);
1297
1298
instance[method_name].apply(instance, args);
1299
}
1300
};
1301
}
1302
1303
1304
/**
1305
*
1306
* ContentHub API backend binding
1307
*
1308
*/
1309
1310
function createContentHubApi(backendDelegate) {
1311
var PLUGIN_URI = 'Ubuntu.Content';
1312
var VERSION = 0.1;
1313
1314
var _contenthub = ContentHubBridge.ContentHub;
1315
1316
// TODO find a better way
1317
function _nameToContentType(name) {
1318
var contentTypePerName = {
1319
"All": ContentHubBridge.ContentType.All,
1320
"Unknown": ContentHubBridge.ContentType.Unknown,
1321
"Pictures": ContentHubBridge.ContentType.Pictures,
1322
"Documents": ContentHubBridge.ContentType.Documents,
1323
"Music": ContentHubBridge.ContentType.Music,
1324
"Contacts": ContentHubBridge.ContentType.Contacts,
1325
};
1326
return name in contentTypePerName ?
1327
contentTypePerName[name]
1328
: ContentHubBridge.ContentType.Unknown;
1329
};
1330
function _contentTypeToName(state) {
1331
if (state === ContentHubBridge.ContentType.All)
1332
return "All";
1333
else if (state === ContentHubBridge.ContentType.Unknown)
1334
return "Unknown";
1335
else if (state === ContentHubBridge.ContentType.Pictures)
1336
return "Pictures";
1337
else if (state === ContentHubBridge.ContentType.Documents)
1338
return "Documents";
1339
else if (state === ContentHubBridge.ContentType.Music)
1340
return "Music";
1341
else if (state === ContentHubBridge.ContentType.Contacts)
1342
return "Contacts";
1343
return "Unknown";
1344
};
1345
1346
function _nameToContentTransferSelection(name) {
1347
var contentTypePerName = {
1348
"Single": ContentHubBridge.ContentTransfer.Single,
1349
"Multiple": ContentHubBridge.ContentTransfer.Multiple,
1350
};
1351
return name in contentTypePerName ?
1352
contentTypePerName[name]
1353
: ContentHubBridge.ContentTransfer.Single;
1354
};
1355
function _contentTransferSelectionToName(state) {
1356
if (state === ContentHubBridge.ContentTransfer.Single)
1357
return "Single";
1358
else if (state === ContentHubBridge.ContentTransfer.Multiple)
1359
return "Multiple";
1360
return "Single";
1361
};
1362
1363
function _nameToContentHandler(name) {
1364
var contentHandlerPerName = {
1365
"Source": ContentHubBridge.ContentHandler.Source,
1366
"Destination": ContentHubBridge.ContentHandler.Destination,
1367
"Share": ContentHubBridge.ContentHandler.Share,
1368
};
1369
return name in contentHandlerPerName ?
1370
contentHandlerPerName[name]
1371
: ContentHubBridge.ContentHandler.Source;
1372
};
1373
function _contentHandlerToName(state) {
1374
if (state === ContentHubBridge.ContentHandler.Source)
1375
return "Source";
1376
else if (state === ContentHubBridge.ContentHandler.Destination)
1377
return "Destination";
1378
else if (state === ContentHubBridge.ContentHandler.Share)
1379
return "Share";
1380
return "Source";
1381
};
1382
1383
function _nameToContentTransferDirection(name) {
1384
var contentTypePerName = {
1385
"Import": ContentHubBridge.ContentTransfer.Import,
1386
"Export": ContentHubBridge.ContentTransfer.Export,
1387
"Share": ContentHubBridge.ContentTransfer.Share,
1388
};
1389
return name in contentTypePerName ?
1390
contentTypePerName[name]
1391
: ContentHubBridge.ContentTransfer.Import;
1392
};
1393
function _contentTransferDirectionToName(state) {
1394
if (state === ContentHubBridge.ContentTransfer.Import)
1395
return "Import";
1396
else if (state === ContentHubBridge.ContentTransfer.Export)
1397
return "Export";
1398
else if (state === ContentHubBridge.ContentTransfer.Share)
1399
return "Share";
1400
return "Import";
1401
};
1402
1403
function _nameToContentScope(name) {
1404
var contentScopePerName = {
1405
"System": ContentHubBridge.ContentScope.System,
1406
"User": ContentHubBridge.ContentScope.User,
1407
"App": ContentHubBridge.ContentScope.App,
1408
};
1409
return name in contentScopePerName ?
1410
contentScopePerName[name]
1411
: ContentHubBridge.ContentScope.App;
1412
};
1413
function _contentScopeToName(state) {
1414
if (state === ContentHubBridge.ContentScope.System)
1415
return "System";
1416
else if (state === ContentHubBridge.ContentScope.User)
1417
return "User";
1418
else if (state === ContentHubBridge.ContentScope.App)
1419
return "App";
1420
return "App";
1421
};
1422
1423
function _nameToContentTransferState(name) {
1424
var contentTransferStatePerName = {
1425
"Created": ContentHubBridge.ContentTransfer.Created,
1426
"Initiated": ContentHubBridge.ContentTransfer.Initiated,
1427
"InProgress": ContentHubBridge.ContentTransfer.InProgress,
1428
"Charged": ContentHubBridge.ContentTransfer.Charged,
1429
"Collected": ContentHubBridge.ContentTransfer.Collected,
1430
"Aborted": ContentHubBridge.ContentTransfer.Aborted,
1431
"Finalized": ContentHubBridge.ContentTransfer.Finalized,
1432
};
1433
return name in contentTransferStatePerName ?
1434
contentTransferStatePerName[name]
1435
: ContentHubBridge.ContentTransfer.Created;
1436
};
1437
function _contentTransferStateToName(state) {
1438
if (state === ContentHubBridge.ContentTransfer.Created)
1439
return "Created";
1440
else if (state === ContentHubBridge.ContentTransfer.Initiated)
1441
return "Initiated";
1442
else if (state === ContentHubBridge.ContentTransfer.InProgress)
1443
return "InProgress";
1444
else if (state === ContentHubBridge.ContentTransfer.Charged)
1445
return "Charged";
1446
else if (state === ContentHubBridge.ContentTransfer.Collected)
1447
return "Collected";
1448
else if (state === ContentHubBridge.ContentTransfer.Aborted)
1449
return "Aborted";
1450
else if (state === ContentHubBridge.ContentTransfer.Finalized)
1451
return "Finalized";
1452
return "<Unknown State>";
1453
};
1454
1455
function ContentTransfer(transfer, objectid) {
1456
var id = objectid;
1457
if ( ! transfer) {
1458
var result = backendDelegate.createQmlObject(
1459
PLUGIN_URI, VERSION, 'ContentTransfer');
1460
id = result.id;
1461
transfer = result.object;
1462
}
1463
if ( ! id) {
1464
id = backendDelegate.storeQmlObject(transfer,
1465
PLUGIN_URI, VERSION, 'ContentTransfer');
1466
}
1467
this._id = id;
1468
this._object = transfer;
1469
this._callback = null;
1470
};
1471
ContentTransfer.prototype = {
1472
_validate: function() {
1473
if (! this._object)
1474
throw new TypeError("Invalid object null");
1475
},
1476
1477
destroy: function() {
1478
if (! this._object)
1479
return;
1480
this._object.destroy();
1481
backendDelegate.deleteId(this._id);
1482
},
1483
1484
// object methods
1485
serialize: function() {
1486
var self = this;
1487
return {
1488
type: 'object-proxy',
1489
apiid: 'ContentHub',
1490
objecttype: 'ContentTransfer',
1491
objectid: self._id,
1492
1493
// serialize immutable values
1494
1495
content: {
1496
store: self._object.store,
1497
state: self._object.state,
1498
selectionType: self._object.selectionType,
1499
direction: self._object.direction,
1500
}
1501
}
1502
},
1503
1504
// properties
1505
1506
store: function(callback) {
1507
this._validate();
1508
callback(this._object.store);
1509
},
1510
setStore: function(storeProxy, callback) {
1511
this._validate();
1512
1513
if (backendDelegate.isObjectProxyInfo(storeProxy)) {
1514
var store = backendDelegate.objectFromId(storeProxy.objectid);
1515
if (store)
1516
this._object.setStore(store);
1517
}
1518
else {
1519
console.debug('setStore: invalid store object proxy');
1520
}
1521
if (callback)
1522
callback();
1523
},
1524
1525
state: function(callback) {
1526
this._validate();
1527
callback(_contentTransferStateToName(this._object.state));
1528
},
1529
setState: function(state, callback) {
1530
this._validate();
1531
this._object.state = _nameToContentTransferState(state);
1532
if (callback && typeof(callback) === 'function')
1533
callback();
1534
},
1535
onStateChanged: function(callback) {
1536
if (!callback || typeof(callback) !== 'function')
1537
return;
1538
this._validate();
1539
var self = this;
1540
this._object.onStateChanged.connect(function() {
1541
callback(_contentTransferStateToName(self._object.state));
1542
});
1543
},
1544
1545
selectionType: function(callback) {
1546
this._validate();
1547
callback(_contentTransferSelectionToName(this._object.selectionType));
1548
},
1549
setSelectionType: function(selectionType, callback) {
1550
this._validate();
1551
this._object.selectionType = _nameToContentTransferSelection(selectionType);
1552
if (callback && typeof(callback) === 'function')
1553
callback();
1554
},
1555
1556
direction: function(callback) {
1557
this._validate();
1558
callback(_contentTransferDirectionToName(this._object.direction));
1559
},
1560
setDirection: function(direction, callback) {
1561
this._validate();
1562
this._object.direction = _nameToContentTransferDirection(direction);
1563
if (callback && typeof(callback) === 'function')
1564
callback();
1565
},
1566
1567
items: function(callback) {
1568
this._validate();
1569
1570
// return in serialized form
1571
callback(this.internal.serializeItems(this._object));
1572
},
1573
setItems: function(items, callback) {
1574
this._validate();
1575
var contentItems = [];
1576
for (var i = 0; i < items.length; ++i) {
1577
var item = backendDelegate.createQmlObject(
1578
PLUGIN_URI, VERSION, 'ContentItem');
1579
if ( ! item.object) {
1580
console.debug('Could not create ContentItem object');
1581
continue;
1582
}
1583
1584
item.object.name = items[i].name;
1585
item.object.url = items[i].url;
1586
1587
contentItems.push(item.object);
1588
}
1589
1590
this._object.items = contentItems;
1591
1592
if (callback && typeof(callback) === 'function')
1593
callback();
1594
},
1595
1596
// methods
1597
start: function(callback) {
1598
this._validate();
1599
1600
var self = this;
1601
this._callback = function () {
1602
callback(_contentTransferStateToName(self._object.state));
1603
};
1604
this._object.stateChanged.connect(this._callback);
1605
1606
this._object.start();
1607
},
1608
finalize: function() {
1609
this._validate();
1610
if (this._callback)
1611
this._object.stateChanged.disconnect(this._callback);
1612
this._callback = null;
1613
this._object.finalize();
1614
},
1615
1616
1617
// internal
1618
internal: {
1619
serializeItems: function(self) {
1620
var items = [];
1621
for (var i = 0; i < self.items.length; ++i) {
1622
items.push({name: self.items[i].name.toString(),
1623
url: self.items[i].url.toString()});
1624
}
1625
return items;
1626
}
1627
}
1628
};
1629
1630
function ContentStore(store, objectid) {
1631
var id = objectid;
1632
if ( ! store) {
1633
var result = backendDelegate.createQmlObject(
1634
PLUGIN_URI, VERSION, 'ContentStore');
1635
id = result.id;
1636
store = result.object;
1637
}
1638
if ( ! id) {
1639
id = backendDelegate.storeQmlObject(store,
1640
PLUGIN_URI, VERSION, 'ContentStore');
1641
}
1642
this._id = id;
1643
this._object = store;
1644
};
1645
ContentStore.prototype = {
1646
_validate: function() {
1647
if (! this._object)
1648
throw new TypeError("Invalid object null");
1649
},
1650
1651
destroy: function() {
1652
if (! this._object)
1653
return;
1654
this._object.destroy();
1655
backendDelegate.deleteId(this._id);
1656
},
1657
1658
// object methods
1659
serialize: function() {
1660
var self = this;
1661
return {
1662
type: 'object-proxy',
1663
apiid: 'ContentHub',
1664
objecttype: 'ContentStore',
1665
objectid: this._id,
1666
1667
// serialize immutable values
1668
1669
content: {
1670
uri: self._object.uri,
1671
scope: _contentScopeToName(self._object.scope),
1672
}
1673
}
1674
},
1675
1676
// properties
1677
1678
scope: function(callback) {
1679
this._validate();
1680
callback(_contentScopeToName(this._object.scope));
1681
},
1682
setScope: function(scope, callback) {
1683
this._validate();
1684
this._object.scope = _nameToContentScope(scope);
1685
if (callback && typeof(callback) === 'function')
1686
callback();
1687
},
1688
1689
//immutable
1690
uri: function(callback) {
1691
this._validate();
1692
callback(this._object.uri);
1693
},
1694
};
1695
1696
function ContentPeer(peer, objectid) {
1697
var id = objectid;
1698
if ( ! peer) {
1699
var result = backendDelegate.createQmlObject(
1700
PLUGIN_URI, VERSION, 'ContentPeer');
1701
id = result.id;
1702
peer = result.object;
1703
}
1704
if ( ! id) {
1705
id = backendDelegate.storeQmlObject(peer,
1706
PLUGIN_URI, VERSION, 'ContentPeer');
1707
}
1708
this._id = id;
1709
this._object = peer;
1710
};
1711
ContentPeer.prototype = {
1712
_validate: function() {
1713
if (! this._object)
1714
throw new TypeError("Invalid object null");
1715
},
1716
1717
destroy: function() {
1718
if (! this._object)
1719
return;
1720
this._object.destroy();
1721
backendDelegate.deleteId(this._id);
1722
},
1723
1724
// object methods
1725
serialize: function() {
1726
var self = this;
1727
return {
1728
type: 'object-proxy',
1729
apiid: 'ContentHub',
1730
objecttype: 'ContentPeer',
1731
objectid: self._id,
1732
1733
// serialize immutable values
1734
1735
content: {
1736
appId: self._object.appId,
1737
name: self._object.name,
1738
handler: self._object.handler,
1739
contentType: self._object.contentType,
1740
selectionType: self._object.selectionType,
1741
isDefaultPeer: self._object.isDefaultPeer,
1742
},
1743
}
1744
},
1745
1746
// properties
1747
1748
appId: function(callback) {
1749
this._validate();
1750
callback(this._object.appId);
1751
},
1752
setAppId: function(appId, callback) {
1753
this._validate();
1754
this._object.appId = appId;
1755
if (callback && typeof(callback) === 'function')
1756
callback();
1757
},
1758
1759
handler: function(callback) {
1760
this._validate();
1761
callback(_contentHandlerToName(this._object.handler));
1762
},
1763
setHandler: function(handler, callback) {
1764
this._validate();
1765
this._object.handler = _nameToContentHandler(handler);
1766
if (callback && typeof(callback) === 'function')
1767
callback();
1768
},
1769
1770
contentType: function(callback) {
1771
this._validate();
1772
callback(_contentTypeToName(this._object.contentType));
1773
},
1774
setContentType: function(contentType, callback) {
1775
this._validate();
1776
this._object.contentType = _nameToContentType(contentType);
1777
if (callback && typeof(callback) === 'function')
1778
callback();
1779
},
1780
1781
selectionType: function(callback) {
1782
this._validate();
1783
callback(_contentTransferSelectionToName(this._object.selectionType));
1784
},
1785
setSelectionType: function(selectionType, callback) {
1786
this._validate();
1787
this._object.selectionType = _nameToContentTransferSelection(selectionType);
1788
if (callback && typeof(callback) === 'function')
1789
callback();
1790
},
1791
1792
// immutable
1793
name: function(callback) {
1794
this._validate();
1795
callback(this._object.name);
1796
},
1797
1798
isDefaultPeer: function(callback) {
1799
this._validate();
1800
callback(this._object.isDefaultPeer);
1801
},
1802
1803
// methods
1804
1805
request: function(callback) {
1806
this._validate();
1807
var transfer = new ContentTransfer(this._object.request());
1808
1809
if (callback && typeof(callback) === 'function')
1810
callback(transfer.serialize());
1811
},
1812
1813
requestForStore: function(store, callback) {
1814
if ( ! store) {
1815
callback(null);
1816
return;
1817
}
1818
1819
if (! backendDelegate.isObjectProxyInfo(store)) {
1820
console.debug('requestForStore: invalid store object proxy')
1821
callback("Invalid store");
1822
return;
1823
}
1824
1825
var _store = backendDelegate.objectFromId(store.objectid);
1826
if ( ! _store) {
1827
callback("Invalid store object (NULL)");
1828
return;
1829
}
1830
this._validate();
1831
1832
var transfer = new ContentTransfer(this._object.request(_store));
1833
if (callback && typeof(callback) === 'function')
1834
callback(transfer.serialize());
1835
},
1836
1837
// internal
1838
1839
internal: {
1840
request: function(self) {
1841
return self._object.request();
1842
}
1843
}
1844
};
1845
1846
function ContentPeerModel(filterParams) {
1847
var result = backendDelegate.createQmlObject(
1848
PLUGIN_URI, VERSION, 'ContentPeerModel', filterParams);
1849
this._id = result.id;
1850
this._object = result.object;
1851
1852
this._modelAdaptor = backendDelegate.createModelAdaptorFor(this._object);
1853
this._roles = this._modelAdaptor.roles();
1854
};
1855
ContentPeerModel.prototype = {
1856
_validate: function() {
1857
if (! this._object)
1858
throw new TypeError("Invalid object null");
1859
},
1860
1861
destroy: function() {
1862
if (! this._object)
1863
return;
1864
this._object.destroy();
1865
this._modelAdaptor.destroy();
1866
backendDelegate.deleteId(this._id);
1867
},
1868
1869
// properties
1870
setContentType: function(contentType, callback) {
1871
this._validate();
1872
this._object.contentType = contentType;
1873
if (callback)
1874
callback();
1875
},
1876
1877
setHandler: function(handler, callback) {
1878
this._validate();
1879
this._object.handler = handler;
1880
if (callback)
1881
callback();
1882
},
1883
1884
peers: function() {
1885
this._validate();
1886
return this._object.peers;
1887
},
1888
1889
// QAbtractListModel prototype
1890
count: function(callback) {
1891
if (!this._modelAdaptor) {
1892
callback(-1);
1893
return;
1894
}
1895
callback(this._modelAdaptor.rowCount());
1896
},
1897
};
1898
1899
function _constructorFromName(className) {
1900
var constructorPerName = {
1901
"ContentPeer": ContentPeer,
1902
"ContentStore": ContentStore,
1903
"ContentTransfer": ContentTransfer,
1904
};
1905
return className in constructorPerName
1906
? constructorPerName[className]
1907
: null;
1908
}
1909
1910
return {
1911
getPeers: function(filters, callback) {
1912
if ( ! filters){
1913
callback(null);
1914
return;
1915
}
1916
1917
var statement = "import QtQuick 2.0; import Ubuntu.Content 0.1; ContentPeerModel {";
1918
var filterParams = {};
1919
if (filters.contentType) {
1920
statement += " contentType: ContentType." + filters.contentType + ";";
1921
}
1922
if (filters.handler) {
1923
statement += " handler: ContentHandler." + filters.handler + ";";
1924
}
1925
statement += " }";
1926
1927
var peerModel = Qt.createQmlObject(statement, backendDelegate.parent());
1928
var onPeersFound = function() {
1929
var peers = peerModel.peers;
1930
1931
var wrappedPeers = [];
1932
for (var i = 0; i < peers.length; ++i) {
1933
var wrappedPeer = new ContentPeer(peers[i]);
1934
wrappedPeers.push(wrappedPeer.serialize());
1935
}
1936
peerModel.onFindPeersCompleted.disconnect(onPeersFound);
1937
callback(wrappedPeers);
1938
};
1939
peerModel.onFindPeersCompleted.connect(onPeersFound);
1940
},
1941
1942
getStore: function(scope, callback) {
1943
if ( ! scope){
1944
callback(null);
1945
return;
1946
}
1947
var store = new ContentStore();
1948
store.setScope(scope);
1949
callback(store.serialize());
1950
},
1951
1952
launchContentPeerPicker: function(filters, onPeerSelected, onCancelPressed) {
1953
if ( ! filters){
1954
callback(null);
1955
return;
1956
}
1957
1958
var parentItem = backendDelegate.parentView();
1959
if ( ! parentItem || ! parentItem.visible || ! parentItem.height || ! parentItem.width) {
1960
console.debug("Cannot launch the content peer picker UI, invalid parent item: " + parentItem);
1961
onCancelPressed();
1962
return;
1963
}
1964
1965
var statement = "import QtQuick 2.0; import Ubuntu.Content 0.1; ContentPeerPicker {";
1966
var filterParams = {};
1967
if (filters.contentType) {
1968
statement += " contentType: ContentType." + filters.contentType + "";
1969
}
1970
if (filters.handler) {
1971
statement += "; handler: ContentHandler." + filters.handler + "";
1972
}
1973
if (filters.showTitle) {
1974
statement += "; showTitle: " + filters.showTitle === false ? "false" : "true";
1975
}
1976
statement += "; visible: true; }";
1977
1978
if (parentItem.parent)
1979
parentItem.visible = false;
1980
var contentPeerPicker = Qt.createQmlObject(statement,
1981
parentItem.parent ? parentItem.parent : parentItem);
1982
function _onPeerSelected() {
1983
var peer = new ContentPeer(contentPeerPicker.peer);
1984
contentPeerPicker.visible = false;
1985
parentItem.visible = true;
1986
onPeerSelected(peer.serialize());
1987
contentPeerPicker.onPeerSelected.disconnect(_onPeerSelected);
1988
contentPeerPicker.destroy();
1989
}
1990
function _onCancelPressed() {
1991
contentPeerPicker.visible = false;
1992
parentItem.visible = true;
1993
onCancelPressed();
1994
contentPeerPicker.onPeerSelected.disconnect(_onCancelPressed);
1995
contentPeerPicker.destroy();
1996
}
1997
1998
contentPeerPicker.onPeerSelected.connect(_onPeerSelected);
1999
contentPeerPicker.onCancelPressed.connect(_onCancelPressed);
2000
},
2001
2002
apiImportContent: function(type, peer, transferOptions, onSuccess, onFailure) {
2003
if (! backendDelegate.isObjectProxyInfo(peer)) {
2004
console.debug('apiImportContent: invalid peer object proxy')
2005
onError("Invalid peer");
2006
return;
2007
}
2008
2009
var _type = _nameToContentType(type);
2010
var _peer = backendDelegate.objectFromId(peer.objectid);
2011
if ( ! _peer) {
2012
onError("Invalid peer object (NULL)");
2013
return;
2014
}
2015
var _transfer = null;
2016
if (transferOptions.scope) {
2017
var store = new ContentStore();
2018
store.setScope(transferOptions.scope);
2019
_transfer = _peer.request(store._object);
2020
}
2021
else {
2022
_transfer = _peer.request();
2023
}
2024
2025
if (transferOptions.multipleFiles) {
2026
_transfer.selectionType = ContentHubBridge.ContentTransfer.Multiple;
2027
}
2028
else {
2029
_transfer.selectionType = ContentHubBridge.ContentTransfer.Single;
2030
}
2031
2032
var transfer = new ContentTransfer(_transfer)
2033
_transfer.stateChanged.connect(function() {
2034
if (_transfer.state === ContentHubBridge.ContentTransfer.Aborted) {
2035
onFailure("Aborted");
2036
return;
2037
}
2038
else if (_transfer.state === ContentHubBridge.ContentTransfer.Charged) {
2039
var d = transfer.internal.serializeItems(_transfer);
2040
onSuccess(d);
2041
_transfer.finalize();
2042
return;
2043
}
2044
});
2045
_transfer.start();
2046
},
2047
2048
onExportRequested: function(callback) {
2049
_contenthub.exportRequested.connect(function(exportTransfer) {
2050
var wrapped = new ContentTransfer(exportTransfer);
2051
callback(wrapped.serialize());
2052
});
2053
},
2054
2055
// Internal
2056
2057
dispatchToObject: function(infos) {
2058
var args = infos.args;
2059
var callback = infos.callback;
2060
var method_name = infos.method_name;
2061
var objectid = infos.objectid;
2062
var class_name = infos.class_name;
2063
2064
if (callback)
2065
args.push(callback);
2066
2067
var o = backendDelegate.objectFromId(objectid);
2068
if (o == null) {
2069
console.debug('Cannot dispatch to unknown object: ' + objectid);
2070
return;
2071
}
2072
2073
var Constructor = _constructorFromName(class_name);
2074
2075
var instance = new Constructor(o, objectid);
2076
2077
instance[method_name].apply(instance, args);
2078
}
2079
};
2080
}
2081
2082
Loggerhead is a web-based interface for Breezy
Version: 2.0.1