Zend/Gdata/YouTube/VideoEntry.php

   1 <?php
   2
   3 /**
   4  * Zend Framework
   5  *
   6  * LICENSE
   7  *
   8  * This source file is subject to the new BSD license that is bundled
   9  * with this package in the file LICENSE.txt.
  10  * It is also available through the world-wide-web at this URL:
  11  * http://framework.zend.com/license/new-bsd
  12  * If you did not receive a copy of the license and are unable to
  13  * obtain it through the world-wide-web, please send an email
  14  * to license@zend.com so we can send you a copy immediately.
  15  *
  16  * @category   Zend
  17  * @package    Zend_Gdata
  18  * @subpackage YouTube
  19  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  20  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  21
  22  */
  23
  24 /**
  25  * @see Zend_Gdata_Extension_Comments
  26  */
  27 require_once 'Zend/Gdata/Extension/Comments.php';
  28
  29 /**
  30  * @see Zend_Gdata_Extension_FeedLink
  31  */
  32 require_once 'Zend/Gdata/Extension/FeedLink.php';
  33
  34 /**
  35  * @see Zend_Gdata_YouTube_MediaEntry
  36  */
  37 require_once 'Zend/Gdata/YouTube/MediaEntry.php';
  38
  39 /**
  40  * @see Zend_Gdata_YouTube_Extension_MediaGroup
  41  */
  42 require_once 'Zend/Gdata/YouTube/Extension/MediaGroup.php';
  43
  44 /**
  45  * @see Zend_Gdata_YouTube_Extension_NoEmbed
  46  */
  47 require_once 'Zend/Gdata/YouTube/Extension/NoEmbed.php';
  48
  49 /**
  50  * @see Zend_Gdata_YouTube_Extension_Statistics
  51  */
  52 require_once 'Zend/Gdata/YouTube/Extension/Statistics.php';
  53
  54 /**
  55  * @see Zend_Gdata_YouTube_Extension_Link
  56  */
  57 require_once 'Zend/Gdata/YouTube/Extension/Link.php';
  58
  59 /**
  60  * @see Zend_Gdata_YouTube_Extension_Racy
  61  */
  62 require_once 'Zend/Gdata/YouTube/Extension/Racy.php';
  63
  64 /**
  65  * @see Zend_Gdata_Extension_Rating
  66  */
  67 require_once 'Zend/Gdata/Extension/Rating.php';
  68
  69 /**
  70  * @see Zend_Gdata_Geo_Extension_GeoRssWhere
  71  */
  72 require_once 'Zend/Gdata/Geo/Extension/GeoRssWhere.php';
  73
  74 /**
  75  * @see Zend_Gdata_YouTube_Extension_Control
  76  */
  77 require_once 'Zend/Gdata/YouTube/Extension/Control.php';
  78
  79 /**
  80  * @see Zend_Gdata_YouTube_Extension_Recorded
  81  */
  82 require_once 'Zend/Gdata/YouTube/Extension/Recorded.php';
  83
  84 /**
  85  * @see Zend_Gdata_YouTube_Extension_Location
  86  */
  87 require_once 'Zend/Gdata/YouTube/Extension/Location.php';
  88
  89 /**
  90  * Represents the YouTube video flavor of an Atom entry
  91  *
  92  * @category   Zend
  93  * @package    Zend_Gdata
  94  * @subpackage YouTube
  95  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  96  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  97  */
  98 class Zend_Gdata_YouTube_VideoEntry extends Zend_Gdata_YouTube_MediaEntry
  99 {
 100
 101     const YOUTUBE_DEVELOPER_TAGS_SCHEMA = 'http://gdata.youtube.com/schemas/2007/developertags.cat';
 102     const YOUTUBE_CATEGORY_SCHEMA = 'http://gdata.youtube.com/schemas/2007/categories.cat';
 103     protected $_entryClassName = 'Zend_Gdata_YouTube_VideoEntry';
 104
 105     /**
 106      * If null, the video can be embedded
 107      *
 108      * @var Zend_Gdata_YouTube_Extension_NoEmbed|null
 109      */
 110     protected $_noEmbed = null;
 111
 112     /**
 113      * Specifies the statistics relating to the video.
 114      *
 115      * @var Zend_Gdata_YouTube_Extension_Statistics
 116      */
 117     protected $_statistics = null;
 118
 119     /**
 120      * If not null, specifies that the video has racy content.
 121      *
 122      * @var Zend_Gdata_YouTube_Extension_Racy|null
 123      */
 124     protected $_racy = null;
 125
 126     /**
 127      * If not null, specifies that the video is private.
 128      *
 129      * @var Zend_Gdata_YouTube_Extension_Private|null
 130      */
 131     protected $_private = null;
 132
 133     /**
 134      * Specifies the video's rating.
 135      *
 136      * @var Zend_Gdata_Extension_Rating
 137      */
 138     protected $_rating = null;
 139
 140     /**
 141      * Specifies the comments associated with a video.
 142      *
 143      * @var Zend_Gdata_Extensions_Comments
 144      */
 145     protected $_comments = null;
 146
 147     /**
 148      * Nested feed links
 149      *
 150      * @var array
 151      */
 152     protected $_feedLink = array();
 153
 154     /**
 155      * Geo location for the video
 156      *
 157      * @var Zend_Gdata_Geo_Extension_GeoRssWhere
 158      */
 159     protected $_where = null;
 160
 161     /**
 162      * Recording date for the video
 163      *
 164      * @var Zend_Gdata_YouTube_Extension_Recorded|null
 165      */
 166     protected $_recorded = null;
 167
 168     /**
 169      * Location informtion for the video
 170      *
 171      * @var Zend_Gdata_YouTube_Extension_Location|null
 172      */
 173     protected $_location = null;
 174
 175     /**
 176      * Creates a Video entry, representing an individual video
 177      *
 178      * @param DOMElement $element (optional) DOMElement from which this
 179      *          object should be constructed.
 180      */
 181     public function __construct($element = null)
 182     {
 183         $this->registerAllNamespaces(Zend_Gdata_YouTube::$namespaces);
 184         parent::__construct($element);
 185     }
 186
 187     /**
 188      * Retrieves a DOMElement which corresponds to this element and all
 189      * child properties.  This is used to build an entry back into a DOM
 190      * and eventually XML text for sending to the server upon updates, or
 191      * for application storage/persistence.
 192      *
 193      * @param DOMDocument $doc The DOMDocument used to construct DOMElements
 194      * @return DOMElement The DOMElement representing this element and all
 195      * child properties.
 196      */
 197     public function getDOM($doc = null, $majorVersion = 1, $minorVersion = null)
 198     {
 199         $element = parent::getDOM($doc, $majorVersion, $minorVersion);
 200         if ($this->_noEmbed != null) {
 201             $element->appendChild($this->_noEmbed->getDOM(
 202                 $element->ownerDocument));
 203         }
 204         if ($this->_statistics != null) {
 205             $element->appendChild($this->_statistics->getDOM(
 206                 $element->ownerDocument));
 207         }
 208         if ($this->_racy != null) {
 209             $element->appendChild($this->_racy->getDOM(
 210                 $element->ownerDocument));
 211         }
 212         if ($this->_recorded != null) {
 213             $element->appendChild($this->_recorded->getDOM(
 214                 $element->ownerDocument));
 215         }
 216         if ($this->_location != null) {
 217             $element->appendChild($this->_location->getDOM(
 218                 $element->ownerDocument));
 219         }
 220         if ($this->_rating != null) {
 221             $element->appendChild($this->_rating->getDOM(
 222                 $element->ownerDocument));
 223         }
 224         if ($this->_comments != null) {
 225             $element->appendChild($this->_comments->getDOM(
 226                 $element->ownerDocument));
 227         }
 228         if ($this->_feedLink != null) {
 229             foreach ($this->_feedLink as $feedLink) {
 230                 $element->appendChild($feedLink->getDOM(
 231                     $element->ownerDocument));
 232             }
 233         }
 234         if ($this->_where != null) {
 235            $element->appendChild($this->_where->getDOM(
 236                 $element->ownerDocument));
 237         }
 238         return $element;
 239     }
 240
 241     /**
 242      * Creates individual Entry objects of the appropriate type and
 243      * stores them in the $_entry array based upon DOM data.
 244      *
 245      * @param DOMNode $child The DOMNode to process
 246      */
 247     protected function takeChildFromDOM($child)
 248     {
 249         $absoluteNodeName = $child->namespaceURI . ':' . $child->localName;
 250
 251         switch ($absoluteNodeName) {
 252         case $this->lookupNamespace('yt') . ':' . 'statistics':
 253             $statistics = new Zend_Gdata_YouTube_Extension_Statistics();
 254             $statistics->transferFromDOM($child);
 255             $this->_statistics = $statistics;
 256             break;
 257         case $this->lookupNamespace('yt') . ':' . 'racy':
 258             $racy = new Zend_Gdata_YouTube_Extension_Racy();
 259             $racy->transferFromDOM($child);
 260             $this->_racy = $racy;
 261             break;
 262         case $this->lookupNamespace('yt') . ':' . 'recorded':
 263             $recorded = new Zend_Gdata_YouTube_Extension_Recorded();
 264             $recorded->transferFromDOM($child);
 265             $this->_recorded = $recorded;
 266             break;
 267         case $this->lookupNamespace('yt') . ':' . 'location':
 268             $location = new Zend_Gdata_YouTube_Extension_Location();
 269             $location->transferFromDOM($child);
 270             $this->_location = $location;
 271             break;
 272         case $this->lookupNamespace('gd') . ':' . 'rating':
 273             $rating = new Zend_Gdata_Extension_Rating();
 274             $rating->transferFromDOM($child);
 275             $this->_rating = $rating;
 276             break;
 277         case $this->lookupNamespace('gd') . ':' . 'comments':
 278             $comments = new Zend_Gdata_Extension_Comments();
 279             $comments->transferFromDOM($child);
 280             $this->_comments = $comments;
 281             break;
 282         case $this->lookupNamespace('yt') . ':' . 'noembed':
 283             $noEmbed = new Zend_Gdata_YouTube_Extension_NoEmbed();
 284             $noEmbed->transferFromDOM($child);
 285             $this->_noEmbed = $noEmbed;
 286             break;
 287         case $this->lookupNamespace('gd') . ':' . 'feedLink':
 288             $feedLink = new Zend_Gdata_Extension_FeedLink();
 289             $feedLink->transferFromDOM($child);
 290             $this->_feedLink[] = $feedLink;
 291             break;
 292         case $this->lookupNamespace('georss') . ':' . 'where':
 293             $where = new Zend_Gdata_Geo_Extension_GeoRssWhere();
 294             $where->transferFromDOM($child);
 295             $this->_where = $where;
 296             break;
 297         case $this->lookupNamespace('atom') . ':' . 'link';
 298             $link = new Zend_Gdata_YouTube_Extension_Link();
 299             $link->transferFromDOM($child);
 300             $this->_link[] = $link;
 301             break;
 302         case $this->lookupNamespace('app') . ':' . 'control':
 303             $control = new Zend_Gdata_YouTube_Extension_Control();
 304             $control->transferFromDOM($child);
 305             $this->_control = $control;
 306             break;
 307         default:
 308             parent::takeChildFromDOM($child);
 309             break;
 310         }
 311     }
 312
 313     /**
 314      * Sets when the video was recorded.
 315      *
 316      * @param Zend_Gdata_YouTube_Extension_Recorded $recorded When the video was recorded
 317      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 318      */
 319     public function setRecorded($recorded = null)
 320     {
 321         $this->_recorded = $recorded;
 322         return $this;
 323     }
 324
 325     /**
 326      * Gets the date that the video was recorded.
 327      *
 328      * @return Zend_Gdata_YouTube_Extension_Recorded|null
 329      */
 330     public function getRecorded()
 331     {
 332         return $this->_recorded;
 333     }
 334
 335     /**
 336      * Sets the location information.
 337      *
 338      * @param Zend_Gdata_YouTube_Extension_Location $location Where the video
 339      *        was recorded
 340      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 341      */
 342     public function setLocation($location = null)
 343     {
 344         $this->_location = $location;
 345         return $this;
 346     }
 347
 348     /**
 349      * Gets the location where the video was recorded.
 350      *
 351      * @return Zend_Gdata_YouTube_Extension_Location|null
 352      */
 353     public function getLocation()
 354     {
 355         return $this->_location;
 356     }
 357
 358     /**
 359      * If an instance of Zend_Gdata_YouTube_Extension_NoEmbed is passed in,
 360      * the video cannot be embedded.  Otherwise, if null is passsed in, the
 361      * video is able to be embedded.
 362      *
 363      * @param Zend_Gdata_YouTube_Extension_NoEmbed $noEmbed Whether or not the
 364      *          video can be embedded.
 365      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 366      */
 367     public function setNoEmbed($noEmbed = null)
 368     {
 369         $this->_noEmbed = $noEmbed;
 370         return $this;
 371     }
 372
 373     /**
 374      * If the return value is an instance of
 375      * Zend_Gdata_YouTube_Extension_NoEmbed, this video cannot be embedded.
 376      *
 377      * @return Zend_Gdata_YouTube_Extension_NoEmbed|null Whether or not the video can be embedded
 378      */
 379     public function getNoEmbed()
 380     {
 381         return $this->_noEmbed;
 382     }
 383
 384     /**
 385      * Checks whether the video is embeddable.
 386      *
 387      * @return bool Returns true if the video is embeddable.
 388      */
 389     public function isVideoEmbeddable()
 390     {
 391         if ($this->getNoEmbed() == null) {
 392             return true;
 393         } else {
 394             return false;
 395         }
 396     }
 397
 398     /**
 399      * Sets the statistics relating to the video.
 400      *
 401      * @param Zend_Gdata_YouTube_Extension_Statistics $statistics The statistics relating to the video
 402      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 403      */
 404     public function setStatistics($statistics = null)
 405     {
 406         $this->_statistics = $statistics;
 407         return $this;
 408     }
 409
 410     /**
 411      * Returns the statistics relating to the video.
 412      *
 413      * @return Zend_Gdata_YouTube_Extension_Statistics  The statistics relating to the video
 414      */
 415     public function getStatistics()
 416     {
 417         return $this->_statistics;
 418     }
 419
 420     /**
 421      * Specifies that the video has racy content.
 422      *
 423      * @param Zend_Gdata_YouTube_Extension_Racy $racy The racy flag object
 424      * @throws Zend_Gdata_App_VersionException
 425      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 426      */
 427     public function setRacy($racy = null)
 428     {
 429         if ($this->getMajorProtocolVersion() == 2) {
 430             require_once 'Zend/Gdata/App/VersionException.php';
 431             throw new Zend_Gdata_App_VersionException(
 432                 'Calling getRacy() on a YouTube VideoEntry is deprecated ' .
 433                 'as of version 2 of the API.');
 434         }
 435
 436         $this->_racy = $racy;
 437         return $this;
 438     }
 439
 440     /**
 441      * Returns the racy flag object.
 442      *
 443      * @throws Zend_Gdata_App_VersionException
 444      * @return Zend_Gdata_YouTube_Extension_Racy|null  The racy flag object
 445      */
 446     public function getRacy()
 447     {
 448         if ($this->getMajorProtocolVersion() == 2) {
 449             require_once 'Zend/Gdata/App/VersionException.php';
 450             throw new Zend_Gdata_App_VersionException(
 451                 'Calling getRacy() on a YouTube VideoEntry is deprecated ' .
 452                 'as of version 2 of the API.');
 453         }
 454         return $this->_racy;
 455     }
 456
 457     /**
 458      * Sets the rating relating to the video.
 459      *
 460      * @param Zend_Gdata_Extension_Rating $rating The rating relating to the video
 461      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 462      */
 463     public function setRating($rating = null)
 464     {
 465         $this->_rating = $rating;
 466         return $this;
 467     }
 468
 469     /**
 470      * Returns the rating relating to the video.
 471      *
 472      * @return Zend_Gdata_Extension_Rating  The rating relating to the video
 473      */
 474     public function getRating()
 475     {
 476         return $this->_rating;
 477     }
 478
 479     /**
 480      * Sets the comments relating to the video.
 481      *
 482      * @param Zend_Gdata_Extension_Comments $comments The comments relating to the video
 483      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 484      */
 485     public function setComments($comments = null)
 486     {
 487         $this->_comments = $comments;
 488         return $this;
 489     }
 490
 491     /**
 492      * Returns the comments relating to the video.
 493      *
 494      * @return Zend_Gdata_Extension_Comments  The comments relating to the video
 495      */
 496     public function getComments()
 497     {
 498         return $this->_comments;
 499     }
 500
 501     /**
 502      * Sets the array of embedded feeds related to the video
 503      *
 504      * @param array $feedLink The array of embedded feeds relating to the video
 505      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 506      */
 507     public function setFeedLink($feedLink = null)
 508     {
 509         $this->_feedLink = $feedLink;
 510         return $this;
 511     }
 512
 513     /**
 514      * Get the feed link property for this entry.
 515      *
 516      * @see setFeedLink
 517      * @param string $rel (optional) The rel value of the link to be found.
 518      *          If null, the array of links is returned.
 519      * @return mixed If $rel is specified, a Zend_Gdata_Extension_FeedLink
 520      *          object corresponding to the requested rel value is returned
 521      *          if found, or null if the requested value is not found. If
 522      *          $rel is null or not specified, an array of all available
 523      *          feed links for this entry is returned, or null if no feed
 524      *          links are set.
 525      */
 526     public function getFeedLink($rel = null)
 527     {
 528         if ($rel == null) {
 529             return $this->_feedLink;
 530         } else {
 531             foreach ($this->_feedLink as $feedLink) {
 532                 if ($feedLink->rel == $rel) {
 533                     return $feedLink;
 534                 }
 535             }
 536             return null;
 537         }
 538     }
 539
 540     /**
 541      * Returns the link element relating to video responses.
 542      *
 543      * @return Zend_Gdata_App_Extension_Link
 544      */
 545     public function getVideoResponsesLink()
 546     {
 547         return $this->getLink(Zend_Gdata_YouTube::VIDEO_RESPONSES_REL);
 548     }
 549
 550     /**
 551      * Returns the link element relating to video ratings.
 552      *
 553      * @return Zend_Gdata_App_Extension_Link
 554      */
 555     public function getVideoRatingsLink()
 556     {
 557         return $this->getLink(Zend_Gdata_YouTube::VIDEO_RATINGS_REL);
 558     }
 559
 560     /**
 561      * Returns the link element relating to video complaints.
 562      *
 563      * @return Zend_Gdata_App_Extension_Link
 564      */
 565     public function getVideoComplaintsLink()
 566     {
 567         return $this->getLink(Zend_Gdata_YouTube::VIDEO_COMPLAINTS_REL);
 568     }
 569
 570     /**
 571      * Gets the YouTube video ID based upon the atom:id value
 572      *
 573      * @return string The video ID
 574      */
 575     public function getVideoId()
 576     {
 577         if ($this->getMajorProtocolVersion() == 2) {
 578             $videoId = $this->getMediaGroup()->getVideoId()->text;
 579         } else {
 580             $fullId = $this->getId()->getText();
 581             $position = strrpos($fullId, '/');
 582             if ($position === false) {
 583                 require_once 'Zend/Gdata/App/Exception.php';
 584                 throw new Zend_Gdata_App_Exception(
 585                     'Slash not found in atom:id of ' . $fullId);
 586             } else {
 587                 $videoId = substr($fullId, $position + 1);
 588             }
 589         }
 590         return $videoId;
 591     }
 592
 593     /**
 594      * Gets the date that the video was recorded.
 595      *
 596      * @return string|null The date that the video was recorded
 597      */
 598     public function getVideoRecorded()
 599     {
 600         $recorded = $this->getRecorded();
 601         if ($recorded != null) {
 602           return $recorded->getText();
 603         } else {
 604           return null;
 605         }
 606     }
 607
 608     /**
 609      * Sets the date that the video was recorded.
 610      *
 611      * @param string $recorded The date that the video was recorded, in the
 612      *          format of '2001-06-19'
 613      */
 614     public function setVideoRecorded($recorded)
 615     {
 616         $this->setRecorded(
 617             new Zend_Gdata_YouTube_Extension_Recorded($recorded));
 618         return $this;
 619     }
 620
 621     /**
 622      * Gets the georss:where element
 623      *
 624      * @return Zend_Gdata_Geo_Extension_GeoRssWhere
 625      */
 626     public function getWhere()
 627     {
 628         return $this->_where;
 629     }
 630
 631     /**
 632      * Sets the georss:where element
 633      *
 634      * @param Zend_Gdata_Geo_Extension_GeoRssWhere $value The georss:where class value
 635      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 636      */
 637     public function setWhere($value)
 638     {
 639         $this->_where = $value;
 640         return $this;
 641     }
 642
 643     /**
 644      * Gets the title of the video as a string.  null is returned
 645      * if the video title is not available.
 646      *
 647      * @return string|null The title of the video
 648      */
 649     public function getVideoTitle()
 650     {
 651         $this->ensureMediaGroupIsNotNull();
 652         if ($this->getMediaGroup()->getTitle() != null) {
 653             return $this->getMediaGroup()->getTitle()->getText();
 654         } else {
 655             return null;
 656         }
 657     }
 658
 659     /**
 660      * Sets the title of the video as a string.
 661      *
 662      * @param string $title Title for the video
 663      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 664      */
 665     public function setVideoTitle($title)
 666     {
 667         $this->ensureMediaGroupIsNotNull();
 668         $this->getMediaGroup()->setTitle(
 669             new Zend_Gdata_Media_Extension_MediaTitle($title));
 670         return $this;
 671     }
 672
 673     /**
 674      * Sets the description of the video as a string.
 675      *
 676      * @param string $description Description for the video
 677      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 678      */
 679     public function setVideoDescription($description)
 680     {
 681         $this->ensureMediaGroupIsNotNull();
 682         $this->getMediaGroup()->setDescription(
 683             new Zend_Gdata_Media_Extension_MediaDescription($description));
 684         return $this;
 685     }
 686
 687
 688     /**
 689      * Gets the description  of the video as a string.  null is returned
 690      * if the video description is not available.
 691      *
 692      * @return string|null The description of the video
 693      */
 694     public function getVideoDescription()
 695     {
 696         $this->ensureMediaGroupIsNotNull();
 697         if ($this->getMediaGroup()->getDescription() != null) {
 698             return $this->getMediaGroup()->getDescription()->getText();
 699         } else {
 700             return null;
 701         }
 702     }
 703
 704     /**
 705      * Gets the URL of the YouTube video watch page.  null is returned
 706      * if the video watch page URL is not available.
 707      *
 708      * @return string|null The URL of the YouTube video watch page
 709      */
 710     public function getVideoWatchPageUrl()
 711     {
 712         $this->ensureMediaGroupIsNotNull();
 713         if ($this->getMediaGroup()->getPlayer() != null &&
 714              array_key_exists(0, $this->getMediaGroup()->getPlayer())) {
 715             $players = $this->getMediaGroup()->getPlayer();
 716             return $players[0]->getUrl();
 717         } else {
 718             return null;
 719         }
 720     }
 721
 722     /**
 723      * Gets an array of the thumbnails representing the video.
 724      * Each thumbnail is an element of the array, and is an
 725      * array of the thumbnail properties - time, height, width,
 726      * and url.  For convient usage inside a foreach loop, an
 727      * empty array is returned if there are no thumbnails.
 728      *
 729      * @return array An array of video thumbnails.
 730      */
 731     public function getVideoThumbnails()
 732     {
 733         $this->ensureMediaGroupIsNotNull();
 734         if ($this->getMediaGroup()->getThumbnail() != null) {
 735
 736             $thumbnailArray = array();
 737
 738             foreach ($this->getMediaGroup()->getThumbnail() as $thumbnailObj) {
 739                 $thumbnail = array();
 740                 $thumbnail['time'] = $thumbnailObj->time;
 741                 $thumbnail['height'] = $thumbnailObj->height;
 742                 $thumbnail['width'] = $thumbnailObj->width;
 743                 $thumbnail['url'] = $thumbnailObj->url;
 744                 $thumbnailArray[] = $thumbnail;
 745             }
 746             return $thumbnailArray;
 747         } else {
 748             return array();
 749         }
 750     }
 751
 752     /**
 753      * Gets the URL of the flash player SWF.  null is returned if the
 754      * duration value is not available.
 755      *
 756      * @return string|null The URL of the flash player SWF
 757      */
 758     public function getFlashPlayerUrl()
 759     {
 760         $this->ensureMediaGroupIsNotNull();
 761         foreach ($this->getMediaGroup()->getContent() as $content) {
 762                 if ($content->getType() === 'application/x-shockwave-flash') {
 763                     return $content->getUrl();
 764                 }
 765             }
 766         return null;
 767     }
 768
 769     /**
 770      * Gets the duration of the video, in seconds.  null is returned
 771      * if the duration value is not available.
 772      *
 773      * @return string|null The duration of the video, in seconds.
 774      */
 775     public function getVideoDuration()
 776     {
 777         $this->ensureMediaGroupIsNotNull();
 778         if ($this->getMediaGroup()->getDuration() != null) {
 779             return $this->getMediaGroup()->getDuration()->getSeconds();
 780         } else {
 781             return null;
 782         }
 783     }
 784
 785     /**
 786      * Checks whether the video is private.
 787      *
 788      * @return bool Return true if video is private
 789      */
 790     public function isVideoPrivate()
 791     {
 792         $this->ensureMediaGroupIsNotNull();
 793         if ($this->getMediaGroup()->getPrivate() != null) {
 794             return true;
 795         } else {
 796             return false;
 797         }
 798     }
 799
 800     /**
 801      * Sets video to private.
 802      *
 803      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 804      */
 805     public function setVideoPrivate()
 806     {
 807         $this->ensureMediaGroupIsNotNull();
 808         $this->getMediaGroup()->setPrivate(new Zend_Gdata_YouTube_Extension_Private());
 809         return $this;
 810     }
 811
 812     /**
 813      * Sets a private video to be public.
 814      *
 815      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 816      */
 817     public function setVideoPublic()
 818     {
 819         $this->ensureMediaGroupIsNotNull();
 820         $this->getMediaGroup()->private = null;
 821         return $this;
 822     }
 823
 824     /**
 825      * Gets an array of the tags assigned to this video.  For convient
 826      * usage inside a foreach loop, an empty array is returned when there
 827      * are no tags assigned.
 828      *
 829      * @return array An array of the tags assigned to this video
 830      */
 831     public function getVideoTags()
 832     {
 833         $this->ensureMediaGroupIsNotNull();
 834         if ($this->getMediaGroup()->getKeywords() != null) {
 835
 836             $keywords = $this->getMediaGroup()->getKeywords();
 837             $keywordsString = $keywords->getText();
 838             if (strlen(trim($keywordsString)) > 0) {
 839                 return preg_split('/(, *)|,/', $keywordsString);
 840             }
 841         }
 842         return array();
 843     }
 844
 845     /**
 846      * Sets the keyword tags for a video.
 847      *
 848      * @param mixed $tags Either a comma-separated string or an array
 849      * of tags for the video
 850      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 851      */
 852     public function setVideoTags($tags)
 853     {
 854         $this->ensureMediaGroupIsNotNull();
 855         $keywords = new Zend_Gdata_Media_Extension_MediaKeywords();
 856         if (is_array($tags)) {
 857             $tags = implode(', ', $tags);
 858         }
 859         $keywords->setText($tags);
 860         $this->getMediaGroup()->setKeywords($keywords);
 861         return $this;
 862     }
 863
 864     /**
 865      * Gets the number of views for this video.  null is returned if the
 866      * number of views is not available.
 867      *
 868      * @return string|null The number of views for this video
 869      */
 870     public function getVideoViewCount()
 871     {
 872         if ($this->getStatistics() != null) {
 873             return $this->getStatistics()->getViewCount();
 874         } else {
 875             return null;
 876         }
 877     }
 878
 879     /**
 880      * Gets the location specified for this video, if available.  The location
 881      * is returned as an array containing the keys 'longitude' and 'latitude'.
 882      * null is returned if the location is not available.
 883      *
 884      * @return array|null The location specified for this video
 885      */
 886     public function getVideoGeoLocation()
 887     {
 888         if ($this->getWhere() != null &&
 889             $this->getWhere()->getPoint() != null &&
 890             ($position = $this->getWhere()->getPoint()->getPos()) != null) {
 891
 892             $positionString = $position->__toString();
 893
 894             if (strlen(trim($positionString)) > 0) {
 895                 $positionArray = explode(' ', trim($positionString));
 896                 if (count($positionArray) == 2) {
 897                     $returnArray = array();
 898                     $returnArray['latitude'] = $positionArray[0];
 899                     $returnArray['longitude'] = $positionArray[1];
 900                     return $returnArray;
 901                 }
 902             }
 903         }
 904         return null;
 905     }
 906
 907     /**
 908      * Gets the rating information for this video, if available.  The rating
 909      * is returned as an array containing the keys 'average' and 'numRaters'.
 910      * null is returned if the rating information is not available.
 911      *
 912      * @return array|null The rating information for this video
 913      */
 914     public function getVideoRatingInfo()
 915     {
 916         if ($this->getRating() != null) {
 917             $returnArray = array();
 918             $returnArray['average'] = $this->getRating()->getAverage();
 919             $returnArray['numRaters'] = $this->getRating()->getNumRaters();
 920             return $returnArray;
 921         } else {
 922             return null;
 923         }
 924     }
 925
 926     /**
 927      * Gets the category of this video, if available.  The category is returned
 928      * as a string. Valid categories are found at:
 929      * http://gdata.youtube.com/schemas/2007/categories.cat
 930      * If the category is not set, null is returned.
 931      *
 932      * @return string|null The category of this video
 933      */
 934     public function getVideoCategory()
 935     {
 936         $this->ensureMediaGroupIsNotNull();
 937         $categories = $this->getMediaGroup()->getCategory();
 938         if ($categories != null) {
 939             foreach($categories as $category) {
 940                 if ($category->getScheme() == self::YOUTUBE_CATEGORY_SCHEMA) {
 941                     return $category->getText();
 942                 }
 943             }
 944         }
 945         return null;
 946     }
 947
 948     /**
 949      * Sets the category of the video as a string.
 950      *
 951      * @param string $category Categories for the video
 952      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 953      */
 954     public function setVideoCategory($category)
 955     {
 956         $this->ensureMediaGroupIsNotNull();
 957         $this->getMediaGroup()->setCategory(array(new Zend_Gdata_Media_Extension_MediaCategory($category, self::YOUTUBE_CATEGORY_SCHEMA)));
 958         return $this;
 959     }
 960
 961     /**
 962      * Gets the developer tags for the video, if available and if client is
 963      * authenticated with a valid developerKey. The tags are returned
 964      * as an array.
 965      * If no tags are set, null is returned.
 966      *
 967      * @return array|null The developer tags for this video or null if none were set.
 968      */
 969     public function getVideoDeveloperTags()
 970     {
 971         $developerTags = null;
 972         $this->ensureMediaGroupIsNotNull();
 973
 974         $categoryArray = $this->getMediaGroup()->getCategory();
 975         if ($categoryArray != null) {
 976             foreach ($categoryArray as $category) {
 977                 if ($category instanceof Zend_Gdata_Media_Extension_MediaCategory) {
 978                     if ($category->getScheme() == self::YOUTUBE_DEVELOPER_TAGS_SCHEMA) {
 979                         $developerTags[] = $category->getText();
 980                     }
 981                 }
 982             }
 983             return $developerTags;
 984         }
 985         return null;
 986     }
 987
 988     /**
 989      * Adds a developer tag to array of tags for the video.
 990      *
 991      * @param string $developerTag DeveloperTag for the video
 992      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
 993      */
 994     public function addVideoDeveloperTag($developerTag)
 995     {
 996         $this->ensureMediaGroupIsNotNull();
 997         $newCategory = new Zend_Gdata_Media_Extension_MediaCategory($developerTag, self::YOUTUBE_DEVELOPER_TAGS_SCHEMA);
 998
 999         if ($this->getMediaGroup()->getCategory() == null) {
1000             $this->getMediaGroup()->setCategory($newCategory);
1001         } else {
1002             $categories = $this->getMediaGroup()->getCategory();
1003             $categories[] = $newCategory;
1004             $this->getMediaGroup()->setCategory($categories);
1005         }
1006         return $this;
1007     }
1008
1009     /**
1010      * Set multiple developer tags for the video as strings.
1011      *
1012      * @param array $developerTags Array of developerTag for the video
1013      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface
1014      */
1015     public function setVideoDeveloperTags($developerTags)
1016     {
1017         foreach($developerTags as $developerTag) {
1018             $this->addVideoDeveloperTag($developerTag);
1019         }
1020         return $this;
1021     }
1022
1023
1024     /**
1025      * Get the current publishing state of the video.
1026      *
1027      * @return Zend_Gdata_YouTube_Extension_State|null The publishing state of this video
1028      */
1029     public function getVideoState()
1030     {
1031         $control = $this->getControl();
1032         if ($control != null &&
1033             $control->getDraft() != null &&
1034             $control->getDraft()->getText() == 'yes') {
1035
1036             return $control->getState();
1037         }
1038         return null;
1039     }
1040
1041     /**
1042      * Get the VideoEntry's Zend_Gdata_YouTube_Extension_MediaGroup object.
1043      * If the mediaGroup does not exist, then set it.
1044      *
1045      * @return void
1046      */
1047     public function ensureMediaGroupIsNotNull()
1048     {
1049         if ($this->getMediagroup() == null) {
1050             $this->setMediagroup(new Zend_Gdata_YouTube_Extension_MediaGroup());
1051         }
1052     }
1053
1054     /**
1055      * Helper function to conveniently set a video's rating.
1056      *
1057      * @param integer $ratingValue A number representing the rating. Must
1058      *          be between 1 and 5 inclusive.
1059      * @throws Zend_Gdata_Exception
1060      * @return Zend_Gdata_YouTube_VideoEntry Provides a fluent interface.
1061      */
1062     public function setVideoRating($ratingValue)
1063     {
1064         if ($ratingValue < 1 || $ratingValue > 5) {
1065             require_once 'Zend/Gdata/App/InvalidArgumentException.php';
1066             throw new Zend_Gdata_App_InvalidArgumentException(
1067                 'Rating for video entry must be between 1 and 5 inclusive.');
1068         }
1069
1070          require_once 'Zend/Gdata/Extension/Rating.php';
1071          $rating = new Zend_Gdata_Extension_Rating(null, 1, 5, null,
1072             $ratingValue);
1073         $this->setRating($rating);
1074         return $this;
1075     }
1076
1077     /**
1078      * Retrieve the URL for a video's comment feed.
1079      *
1080      * @return string|null The URL if found, or null if not found.
1081      */
1082     public function getVideoCommentFeedUrl()
1083     {
1084         $commentsExtension = $this->getComments();
1085         $commentsFeedUrl = null;
1086         if ($commentsExtension) {
1087             $commentsFeedLink = $commentsExtension->getFeedLink();
1088             if ($commentsFeedLink) {
1089                 $commentsFeedUrl = $commentsFeedLink->getHref();
1090             }
1091         }
1092         return $commentsFeedUrl;
1093     }
1094
1095 }