src/content/js/manager.js

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 var T_ = xwalk.utils.type;
  18 var privUtils_ = xwalk.utils;
  19 var CONTENT_MANAGER_LISTENER_ID = 'ContentManagerChangeCallback';
  20
  21 function _ContentManagerChangeCallback(result) {
  22     if (result.state === 'oncontentadded' || result.state === 'oncontentupdated') {
  23         var content = native_.getResultObject(result);
  24         native_.callIfPossible(this[result.state], createContentObject_(content));
  25     } else if (
  26         result.state === 'oncontentdiradded' ||
  27         result.state === 'oncontentdirupdated'
  28     ) {
  29         var contentDir = native_.getResultObject(result);
  30         native_.callIfPossible(this[result.state], createContentDirObject_(contentDir));
  31     } else if (
  32         result.state === 'oncontentremoved' ||
  33         result.state === 'oncontentdirremoved'
  34     ) {
  35         native_.callIfPossible(this[result.state], native_.getResultObject(result));
  36     }
  37 }
  38
  39 var ContentListenersManager = (function() {
  40     function changeContent(event) {
  41         if (T_.isEmptyObject(this.listeners)) {
  42             return;
  43         }
  44
  45         var result = null;
  46
  47         if (event.state === 'oncontentadded' || event.state === 'oncontentupdated') {
  48             result = createContentObject_(native_.getResultObject(event));
  49         } else if (
  50             event.state === 'oncontentdiradded' ||
  51             event.state === 'oncontentdirupdated'
  52         ) {
  53             result = createContentDirObject_(native_.getResultObject(event));
  54         } else if (
  55             event.state === 'oncontentremoved' ||
  56             event.state === 'oncontentdirremoved'
  57         ) {
  58             result = native_.getResultObject(event);
  59         }
  60
  61         if (!result) {
  62             return;
  63         }
  64
  65         var callback;
  66         for (var listenerId in this.listeners) {
  67             if (this.listeners.hasOwnProperty(listenerId)) {
  68                 callback = this.listeners[listenerId];
  69                 if (T_.isFunction(callback[event.state])) {
  70                     callback[event.state](result);
  71                 }
  72             }
  73         }
  74     }
  75
  76     function _ContentListenersManager() {
  77         this.listeners = {};
  78         this.lastListenerId = 0;
  79         this.changeContent = changeContent.bind(this);
  80     }
  81
  82     _ContentListenersManager.prototype.addChangeListener = function(changeCallback) {
  83         if (T_.isEmptyObject(this.listeners)) {
  84             var result = native_.callSync('ContentManagerAddChangeListener');
  85             if (native_.isFailure(result)) {
  86                 throw native_.getErrorObject(result);
  87             }
  88
  89             native_.addListener(CONTENT_MANAGER_LISTENER_ID, this.changeContent);
  90         }
  91
  92         this.listeners[++this.lastListenerId] = changeCallback;
  93         return this.lastListenerId;
  94     };
  95
  96     _ContentListenersManager.prototype.removeChangeListener = function(listenerId) {
  97         delete this.listeners[listenerId];
  98
  99         if (T_.isEmptyObject(this.listeners)) {
 100             var result = native_.callSync('ContentManagerRemoveChangeListener');
 101             if (native_.isFailure(result)) {
 102                 throw native_.getErrorObject(result);
 103             }
 104
 105             native_.removeListener(CONTENT_MANAGER_LISTENER_ID);
 106         }
 107     };
 108
 109     return _ContentListenersManager;
 110 })();
 111
 112 var listenersManager = new ContentListenersManager();
 113
 114 function ContentManager() {}
 115
 116 var ContentManagerUpdate = function(content) {
 117     var args = validator_.validateArgs(arguments, [
 118         { name: 'content', type: types_.PLATFORM_OBJECT, values: Content }
 119     ]);
 120
 121     var data = {
 122         content: args.content
 123     };
 124
 125     var result = native_.callSync('ContentManagerUpdate', data);
 126
 127     if (native_.isFailure(result)) {
 128         throw native_.getErrorObject(result);
 129     }
 130 };
 131
 132 ContentManager.prototype.update = function() {
 133     ContentManagerUpdate.apply(this, arguments);
 134 };
 135
 136 ContentManager.prototype.updateBatch = function(
 137     contents,
 138     successCallback,
 139     errorCallback
 140 ) {
 141     var args = validator_.validateArgs(arguments, [
 142         { name: 'contents', type: types_.ARRAY, values: Content },
 143         {
 144             name: 'successCallback',
 145             type: types_.FUNCTION,
 146             optional: true,
 147             nullable: true
 148         },
 149         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 150     ]);
 151
 152     var data = {
 153         contents: args.contents
 154     };
 155
 156     var callback = function(result) {
 157         if (native_.isFailure(result)) {
 158             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 159             return;
 160         }
 161         native_.callIfPossible(args.successCallback);
 162     };
 163
 164     var result = native_.call('ContentManagerUpdatebatch', data, callback);
 165
 166     if (native_.isFailure(result)) {
 167         throw native_.getErrorObject(result);
 168     }
 169 };
 170
 171 ContentManager.prototype.getDirectories = function(successCallback, errorCallback) {
 172     var args = validator_.validateArgs(arguments, [
 173         { name: 'successCallback', type: types_.FUNCTION },
 174         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 175     ]);
 176
 177     var callback = function(result) {
 178         if (native_.isFailure(result)) {
 179             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 180             return;
 181         }
 182
 183         var out = [];
 184         result = native_.getResultObject(result);
 185         for (var i = 0, max = result.length; i < max; i++) {
 186             out.push(new ContentDirectory(result[i]));
 187         }
 188         native_.callIfPossible(args.successCallback, out);
 189     };
 190
 191     var result = native_.call('ContentManagerGetdirectories', null, callback);
 192
 193     if (native_.isFailure(result)) {
 194         throw native_.getErrorObject(result);
 195     }
 196 };
 197
 198 ContentManager.prototype.find = function(
 199     successCallback,
 200     errorCallback,
 201     directoryId,
 202     filter,
 203     sortMode,
 204     count,
 205     offset
 206 ) {
 207     var args = validator_.validateArgs(arguments, [
 208         { name: 'successCallback', type: types_.FUNCTION },
 209         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true },
 210         { name: 'directoryId', type: types_.STRING, optional: true, nullable: true },
 211         {
 212             name: 'filter',
 213             type: types_.PLATFORM_OBJECT,
 214             values: [
 215                 tizen.AttributeFilter,
 216                 tizen.AttributeRangeFilter,
 217                 tizen.CompositeFilter
 218             ],
 219             optional: true,
 220             nullable: true
 221         },
 222         {
 223             name: 'sortMode',
 224             type: types_.PLATFORM_OBJECT,
 225             values: tizen.SortMode,
 226             optional: true,
 227             nullable: true
 228         },
 229         { name: 'count', type: types_.UNSIGNED_LONG, optional: true, nullable: true },
 230         { name: 'offset', type: types_.UNSIGNED_LONG, optional: true, nullable: true }
 231     ]);
 232
 233     var data = {
 234         directoryId: args.directoryId,
 235         filter: utils_.repackFilter(args.filter),
 236         sortMode: args.sortMode,
 237         count: args.count,
 238         offset: args.offset
 239     };
 240
 241     var callback = function(result) {
 242         if (native_.isFailure(result)) {
 243             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 244             return;
 245         }
 246
 247         var out = [];
 248         result = native_.getResultObject(result);
 249         try {
 250             for (var i = 0, max = result.length; i < max; i++) {
 251                 out.push(createContentObject_(result[i]));
 252             }
 253         } catch (e) {
 254             native_.callIfPossible(args.errorCallback, e);
 255             return;
 256         }
 257
 258         native_.callIfPossible(args.successCallback, out);
 259     };
 260
 261     var result = native_.call('ContentManagerFind', data, callback);
 262
 263     if (native_.isFailure(result)) {
 264         throw native_.getErrorObject(result);
 265     }
 266 };
 267
 268 ContentManager.prototype.scanFile = function(contentURI, successCallback, errorCallback) {
 269     var args = validator_.validateArgs(arguments, [
 270         { name: 'contentURI', type: types_.STRING },
 271         {
 272             name: 'successCallback',
 273             type: types_.FUNCTION,
 274             optional: true,
 275             nullable: true
 276         },
 277         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 278     ]);
 279
 280     var path = args.contentURI.trim();
 281     if (!path.length) {
 282         throw new WebAPIException(
 283             WebAPIException.INVALID_VALUES_ERR,
 284             'File path is not valid.'
 285         );
 286     }
 287
 288     var data = {
 289         contentURI: convertUriToPath_(path)
 290     };
 291
 292     var callback = function(result) {
 293         if (native_.isFailure(result)) {
 294             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 295             return;
 296         }
 297         native_.callIfPossible(args.successCallback, args.contentURI);
 298     };
 299
 300     var result = native_.call('ContentManagerScanfile', data, callback);
 301
 302     if (native_.isFailure(result)) {
 303         throw native_.getErrorObject(result);
 304     }
 305 };
 306
 307 ContentManager.prototype.scanDirectory = function(
 308     contentDirURI,
 309     recursive,
 310     successCallback,
 311     errorCallback
 312 ) {
 313     var args = validator_.validateArgs(arguments, [
 314         { name: 'contentDirURI', type: types_.STRING },
 315         { name: 'recursive', type: types_.BOOLEAN },
 316         {
 317             name: 'successCallback',
 318             type: types_.FUNCTION,
 319             optional: true,
 320             nullable: true
 321         },
 322         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 323     ]);
 324
 325     var path = args.contentDirURI.trim();
 326     if (!path.length) {
 327         throw new WebAPIException(
 328             WebAPIException.INVALID_VALUES_ERR,
 329             'Directory path is not valid.'
 330         );
 331     }
 332
 333     var data = {
 334         contentDirURI: convertUriToPath_(path),
 335         recursive: args.recursive
 336     };
 337
 338     var callback = function(result) {
 339         if (native_.isFailure(result)) {
 340             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 341             return;
 342         }
 343         native_.callIfPossible(args.successCallback, args.contentDirURI);
 344     };
 345
 346     var result = native_.call('ContentManagerScanDirectory', data, callback);
 347
 348     if (native_.isFailure(result)) {
 349         throw native_.getErrorObject(result);
 350     }
 351 };
 352
 353 ContentManager.prototype.cancelScanDirectory = function(contentDirURI) {
 354     var args = validator_.validateArgs(arguments, [
 355         { name: 'contentDirURI', type: types_.STRING }
 356     ]);
 357
 358     var path = args.contentDirURI.trim();
 359     if (!path.length) {
 360         throw new WebAPIException(
 361             WebAPIException.INVALID_VALUES_ERR,
 362             'Directory path is not valid.'
 363         );
 364     }
 365
 366     var data = {
 367         contentDirURI: convertUriToPath_(path)
 368     };
 369
 370     var result = native_.callSync('ContentManagerCancelScanDirectory', data);
 371
 372     if (native_.isFailure(result)) {
 373         throw native_.getErrorObject(result);
 374     }
 375 };
 376
 377 ContentManager.prototype.addChangeListener = function() {
 378     var args = validator_.validateArgs(arguments, [
 379         {
 380             name: 'changeCallback',
 381             type: types_.LISTENER,
 382             values: [
 383                 'oncontentadded',
 384                 'oncontentupdated',
 385                 'oncontentremoved',
 386                 'oncontentdiradded',
 387                 'oncontentdirupdated',
 388                 'oncontentdirremoved'
 389             ]
 390         }
 391     ]);
 392
 393     return listenersManager.addChangeListener(args.changeCallback);
 394 };
 395
 396 ContentManager.prototype.removeChangeListener = function() {
 397     var args = validator_.validateArgs(arguments, [
 398         {
 399             name: 'listenerId',
 400             type: types_.LONG
 401         }
 402     ]);
 403
 404     listenersManager.removeChangeListener(args.listenerId);
 405 };
 406
 407 ContentManager.prototype.setChangeListener = function(changeCallback) {
 408     privUtils_.deprecationWarn(
 409         'setChangeListener() is deprecated and will be removed ' +
 410             'from next release. Use addChangeListener() instead.',
 411         '3.0'
 412     );
 413
 414     var args = validator_.validateArgs(arguments, [
 415         {
 416             name: 'changeCallback',
 417             type: types_.LISTENER,
 418             values: [
 419                 'oncontentadded',
 420                 'oncontentupdated',
 421                 'oncontentremoved',
 422                 'oncontentdiradded',
 423                 'oncontentdirupdated',
 424                 'oncontentdirremoved'
 425             ]
 426         }
 427     ]);
 428
 429     var listenerId = 'ContentManagerChangeCallback_';
 430
 431     var data = {
 432         listenerId: listenerId
 433     };
 434
 435     var callbacks = {
 436         oncontentadded: args.changeCallback.oncontentadded,
 437         oncontentupdated: args.changeCallback.oncontentupdated,
 438         oncontentremoved: args.changeCallback.oncontentremoved,
 439         oncontentdiradded: args.changeCallback.oncontentdiradded,
 440         oncontentdirupdated: args.changeCallback.oncontentdirupdated,
 441         oncontentdirremoved: args.changeCallback.oncontentdirremoved
 442     };
 443
 444     var result = native_.callSync('ContentManagerSetchangelistener', data);
 445
 446     if (native_.isFailure(result)) {
 447         throw native_.getErrorObject(result);
 448     }
 449
 450     native_.addListener(
 451         'ContentManagerChangeCallback_',
 452         _ContentManagerChangeCallback.bind(callbacks)
 453     );
 454 };
 455
 456 ContentManager.prototype.unsetChangeListener = function() {
 457     privUtils_.deprecationWarn(
 458         'unsetChangeListener() is deprecated and will be removed ' +
 459             'from next release. Use removeChangeListener() instead.',
 460         '3.0'
 461     );
 462
 463     var data = {};
 464
 465     var result = native_.callSync('ContentManagerUnsetchangelistener', data);
 466
 467     if (native_.isFailure(result)) {
 468         throw native_.getErrorObject(result);
 469     }
 470
 471     native_.removeListener('ContentManagerChangeCallback_');
 472 };
 473
 474 ContentManager.prototype.getPlaylists = function(successCallback, errorCallback) {
 475     var args = validator_.validateArgs(arguments, [
 476         { name: 'successCallback', type: types_.FUNCTION },
 477         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 478     ]);
 479
 480     var data = {};
 481
 482     var callback = function(result) {
 483         if (native_.isFailure(result)) {
 484             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 485             return;
 486         }
 487         var out = [];
 488         result = native_.getResultObject(result);
 489         for (var i = 0, max = result.length; i < max; i++) {
 490             out.push(new Playlist(result[i]));
 491         }
 492         native_.callIfPossible(args.successCallback, out);
 493     };
 494
 495     var result = native_.call('ContentManagerGetplaylists', data, callback);
 496
 497     if (native_.isFailure(result)) {
 498         throw native_.getErrorObject(result);
 499     }
 500 };
 501
 502 ContentManager.prototype.createPlaylist = function(
 503     name,
 504     successCallback,
 505     errorCallback,
 506     sourcePlaylist
 507 ) {
 508     var args = validator_.validateArgs(arguments, [
 509         { name: 'name', type: types_.STRING },
 510         { name: 'successCallback', type: types_.FUNCTION },
 511         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true },
 512         {
 513             name: 'sourcePlaylist',
 514             type: types_.PLATFORM_OBJECT,
 515             values: Playlist,
 516             optional: true,
 517             nullable: true
 518         }
 519     ]);
 520
 521     if (
 522         !arguments.length ||
 523         !type_.isString(arguments[0]) ||
 524         (type_.isString(arguments[0]) && !arguments[0].length)
 525     ) {
 526         setTimeout(function() {
 527             args.errorCallback(new WebAPIException(WebAPIException.INVALID_VALUES_ERR));
 528         }, 0);
 529         return;
 530     }
 531
 532     var data = {
 533         name: args.name,
 534         sourcePlaylist: args.sourcePlaylist
 535     };
 536
 537     var callback = function(result) {
 538         if (native_.isFailure(result)) {
 539             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 540             return;
 541         }
 542         native_.callIfPossible(
 543             args.successCallback,
 544             new Playlist(native_.getResultObject(result))
 545         );
 546     };
 547
 548     var result = native_.call('ContentManagerCreateplaylist', data, callback);
 549
 550     if (native_.isFailure(result)) {
 551         throw native_.getErrorObject(result);
 552     }
 553 };
 554
 555 ContentManager.prototype.removePlaylist = function(id, successCallback, errorCallback) {
 556     var args = validator_.validateArgs(arguments, [
 557         { name: 'id', type: types_.STRING },
 558         {
 559             name: 'successCallback',
 560             type: types_.FUNCTION,
 561             optional: true,
 562             nullable: true
 563         },
 564         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 565     ]);
 566
 567     var data = {
 568         id: args.id
 569     };
 570
 571     var callback = function(result) {
 572         if (native_.isFailure(result)) {
 573             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 574             return;
 575         }
 576         native_.callIfPossible(args.successCallback);
 577     };
 578
 579     var result = native_.call('ContentManagerRemoveplaylist', data, callback);
 580
 581     if (native_.isFailure(result)) {
 582         throw native_.getErrorObject(result);
 583     }
 584 };
 585
 586 ContentManager.prototype.createThumbnail = function(
 587     content,
 588     successCallback,
 589     errorCallback
 590 ) {
 591     var args = validator_.validateArgs(arguments, [
 592         { name: 'content', type: types_.PLATFORM_OBJECT, values: Content },
 593         { name: 'successCallback', type: types_.FUNCTION },
 594         { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
 595     ]);
 596
 597     var data = {
 598         id: args.content.id
 599     };
 600
 601     var callback = function(result) {
 602         if (native_.isFailure(result)) {
 603             native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
 604             return;
 605         }
 606         args.successCallback(native_.getResultObject(result));
 607     };
 608
 609     var result = native_.call('ContentManagerCreateThumbnail', data, callback);
 610
 611     if (native_.isFailure(result)) {
 612         throw native_.getErrorObject(result);
 613     }
 614 };
 615
 616 exports = new ContentManager();