We’ve got a new template designed by Viddler’s Lead Designer Andrew Smith which will facilitate our needs not only for the Developer site but also for a few other sub-level domains we’ll be launching in the next few weeks.  Andrew provided me with a style guide of sorts and so now I’m put to the task of getting both Wordpress and MediaWiki, the two applications we use to pull off this site, to bend to my will.

Everything should work ok, but will look a little wonky while I’m updating. If you have any concerns, let me know.

Changes in beta 0.2

• Sharing via Twitter now works, even when logged out of Twitter.com.
• Window is now resizable.

To upgrade or install

To update your bookmarklet, just delete the old one, and use this new one: ViddlerPop!

As always, if you have any questions, just ask.

This is where ViddlerPop!, a new bookmarklet we’re playing with, comes in and saves the day.  Now instead of keeping a browser tab open dedicated to a Viddler video, I can watch this video in its own window.

Here is a quick video demonstration of how this first version works.

Please leave us some feedback to let us know what you think of the bookmarklet, how you’d like it to improve, and if you find any bugs.  Thanks in advance!

Installation

To install ViddlerPop! just drag the ViddlerPop! link to your browser’s bookmarks bar - or, right-click and “Add to bookmarks”. I believe in Firefox it is right-click and “Bookmark this Link”.

Questions?  Fire away!

Please stay tuned!

First off, if you haven’t checked out part one and part two of the phpViddler series, you’ll want to do that first, as some of that code will be necessary for recording.

As explained on the wiki page, there are 2 steps to embedding the video recorder on your site:

1. Get a record_token using either Viddler.users.auth with get_record_token set to “1″ or Viddler.videos.getRecordToken.
2. Use the returned record_token to embed the recorder on your site.

Getting A Record Token

In order to embed the video recorder, you’ll need to pass a “record token,” which is a one-time use key that allows the user to record a video. There are two ways to get the record token, so I’ll go through both.

During User Authentication

When you use the user_authenticate() function (covered in part 2), you can pass a third parameter to return a record token, which is then returned along with the sessionid:

<?php
$sessionResponse = $viddler->user_authenticate('user', 'password', '1');
$recordToken = $sessionResponse['auth']['record_token'];
?>

After Authentication

If you already have a valid sessionID, but you haven’t yet generated a record token, you can use the video_getrecordtoken() method, which takes a sessionID as a parameter. Here’s how you’d use it:

<?php
$recordToken = $viddler->video_getrecordtoken($sessionID);
?>

Personally, I prefer grabbing the token during authentication, since it cuts down on the number of API calls I have to make, but it really depends on the situation.

Note: While sessionIDs expire, as you no doubt learned in part two, record tokens never expire but can only be used once. So if you generate a record token for the user when they login, you can keep this token until it is used for as long as you’d like.

Embedding the Video Recorder

Now that you have your record token, it’s time to embed the video recorder. Thankfully, phpViddler makes it easy again with the video_getRecordEmbed() function. To use it, just pass it a record token:

<?php
echo $viddler->video_getRecordEmbed($recordToken);
?>

And with that, your users are ready to record videos right from your site!

Knowing When Recording is Finished

After your user successfully records a video, you’ll likely want to send them to a new page, or call some other action. Luckily, the video recorder calls a javascript function, recordDone() when it’s finished. To implement this, you’ll have to add something like the following to your record page:

As you can see, recordDone() receives 3 arguments, which you can use however you’d like:

• username: The user who recorded a video
• user_video_number: The number that appears in the video’s Viddler URL, e.g. http://www.viddler.com/explore/kyleslat/videos/24/
• video_id: The video’s unique ID, which can be used to embed the player.

So, there you have it, with a few simple lines of code, users are now able to record video directly from your site! Next up, we’ll be tackling uploading videos, so stay tuned.

<img src="http://lab.viddler.com/services/avatar/USERNAME" />

Just replace “USERNAME” with the username whose avatar you want to display. For example, here’s mine, using vAvatar:

Is there anything else you’d like vAvatar to do? Let us know in the comments.

I think you’ll find, through these tutorials, that using phpViddler makes it dead simple to use Viddler’s APIs. Please leave feedback if you have any specific areas you’d like us to cover.

Authenticating a user

To authenticate a user you will need both the username and password of the user. For this example, we’ll say the username is my username, cdevroe, and the password will be a fake password of ‘password’.

There are a few important points to remember when authenticating a user using Viddler’s API, whether you use phpViddler or not. Each time you authenticate a user you are giving a sessionID representing a “session” for that username and password. If you are looking to log in a different user, you will need to re-authenticate the credentials to get another sessionID.

As we move forward with this series, you will learn more about where you use a sessionID to do things like changing meta data, uploading video, etcetera.

To start a new session, this is the code you will need to use once you have the username and password for the user.

<?php
// Authenticate the user, return array of response
$sessionResponse = $viddler->user_authenticate('cdevroe','password');
?>

By default, phpViddler will return a multi-dimensional array of the Viddler.users.auth API method.

Check for errors before you do anything. Typical authentication errors are that the username does not exist (error code 101), or the password provided is incorrect (error code 103).

Once you’ve determined there are no errors, you can now put the sessionID into a variable for use later. In our next parts, we’ll be using the sessionID in a number of ways.

<?php
// Store sessionID in variable.
$sessionID = $sessionResponse['auth']['sessionid'];
?>

Notes about sessions

SessionIDs expire after 15 minutes of inactivity. You should build your application with this in mind. For example, if you build an uploading tool, and the upload of a video file takes longer than 15 minutes, the session you are using to upload a video with will expire before your upload is finished. Don’t panic! All you need to do is ask for a new one and you’re all set.

(Super side note: If you come to a point in your code where you need a sessionID, you can quickly run any method that requires a sessionID to see if the session is still valid, if it isn’t, get a new one, and continue your code.)

In our next part, we’ll be covering the use of our Record with Webcam API and uploading video files.

If you have any questions about authenticating users, or sessions in general, feel free to ask.

$ gem install viddler

For more information, check out Viddler.rb’s documentation.

Today, I’ll be covering how to list videos using the Viddler API and phpViddler using the functions videos_listbyuser, videos_listbytag, and videos_listfeatured.

Getting Set up

To start using the Viddler API, you’ll need to get an API key, which you can get by filling out this form. Once you’ve received your API key, go ahead and download phpViddler from our wiki. Now onto the actual code. To get phpViddler going, you’re going to need to add the following to your script:

<?php
  include_once('phpviddler.php');

  $viddler = new Phpviddler();
  $viddler->apiKey = 'YOUR API KEY';
?>

So what happened here? We included the ‘phpviddler.php’ file, which houses the Phpviddler class. Next, we created a new instance of the Phpviddler class called $viddler, and then finally we set the API key for phpViddler to use.

Getting A User’s Videos

One of the first things you’ll likely want to do is get videos by a specific user. To accomplish this, we’ll be using the videos_listbyuser() function, which calls the viddler.videos.getByUser API method. We’ll then want to display each video using video_getEmbed(). Here’s the code:

$videos = $viddler->videos_listbyuser('username');

foreach($videos['video_list']['video'] as $video) {
  echo $viddler->getEmbed($video['id']);
}

Replace “username” with the username you’re looking up, the above code will retrieve and display all of their videos. First, let’s go over what each line does.

$videos = $viddler->videos_listbyuser('username');

Here we’re just calling the videos_listbyuser() function and passing “username” as an argument. If you look at the code for videos_listbyuser(), you’ll notice it actually takes 4 arguments: $user, $page, $per_page, and $sessionid. We’ll ignore $sessionid for now, since we’ll be covering sessions in a later post. $page and $per_page are used for limiting your results. So, if you want to page through results and have 5 per page, you’d use the following call:

$videos = $viddler->videos_listbyuser('username', 1, 5);

Just change $page to go to the next set of videos. Now, onto handling what Phpviddler returns:

Whenever you make a call using phpViddler, you’ll get an array returned. For instance, the above call, if you put in “winelibrarytv” for a user, you’ll get something like the following:

Array
(
    [video_list attr] => Array
        (
            [total] => 456
        )

    [video_list] => Array
        (
            [video] => Array
                (
                    [0] => Array
                        (
                            [author] => winelibrarytv
                            [id] => c866e246
                            [title] => episode445
                            [length_seconds] => 860
                            [description] =>
                            [view_count] => 1452
                            [upload_time] => 1208384555000
                            [comment_count] => 0
                            [url] => http://www.viddler.com/explore/winelibrarytv/videos/522/
                            [thumbnail_url] => http://cdn-ll-46.viddler.com/e2/thumbnail_2_c866e246.jpg
                        )

                    [1] => Array
                        (
                            [author] => winelibrarytv
                            [id] => add5b980
                            [title] => episode444
                            [length_seconds] => 1090
                            [description] =>
                            [view_count] => 17216
                            [upload_time] => 1208288599000
                            [comment_count] => 0
                            [url] => http://www.viddler.com/explore/winelibrarytv/videos/520/
                            [thumbnail_url] => http://cdn-ll-80.viddler.com/e2/thumbnail_2_add5b980.jpg
                        )

                )

        )

)

So, to iterate through the videos, you just need to use a foreach loop with the $videos[’video_list’][’video’] array:

foreach($videos['video_list']['video'] as $video) {
  echo $viddler->getEmbed($video['id']);
}

Passing the video id to $viddler->getEmbed() returns the proper embed code for the video.

Other Video List Functions

There are a couple other functions in phpViddler which behave similar to videos_listbyuser(): videos_listbytag() and videos_listfeatured().

videos_listbytag($tag, $page, $per_page)

This function utilizes the Viddler.videos.getByTag API call and can take 3 arguments, $tag, $page, and $per_page. $tag refers to the tag you’re searching by, and $page and $per_page behave the same as before. Here’s how you would use it to get all videos tagged with “metoday”:

$videos = $viddler->videos_listbytag('metoday');  

foreach($videos['video_list']['video'] as $video) {
  echo $viddler->getEmbed($video['id']);
}

videos_listfeatured()

Using this function enables you to get all the videos featured on the main Viddler Blog and uses the Viddler.videos.getFeatured API call. It doesn’t require any arguments, so you would just use it like this:

$videos = $viddler->videos_listfeatured();

foreach($videos['video_list']['video'] as $video) {
  echo $viddler->getEmbed($video['id']);
}

More to come

And, with that, we’ve finished our look at how to list videos with phpViddler. Over the next couple of weeks, we’ll be posting more tutorials, so make sure to subscribe to our RSS feed and keep checking back! Also, if you ever have any questions, you can either leave a comment on the blog, or start a new thread in the Developers group.

As it stands you have to do some digging into the HTML embed code to get the values you need to make this plugin work, but perhaps someone with some Joomla! experience can help Antonio out by using oEmbed to make this process even easier?

It is a great first step for Joomla! users.  Thanks Antonio!