(Perl) Facebook Download all Photos to Local Files

Demonstrates how to download all of one's Facebook photos to a local filesystem directory. This sample code keeps a local cache to avoid re-downloading the same photos twice. The program can be run again after a time, and it will download only photos that haven't yet been downloaded.

Chilkat Perl Downloads Perl Module for Windows, MacOS, Linux, Alpine Linux, Solaris

use chilkat();

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

# This example will use a local disk cache to avoid re-fetching the same
# photo id after it's been fetched once.
$fbCache = chilkat::CkCache->new();
# The cache will use 1 level of 256 sub-directories.
$fbCache->put_Level(1);
# Use a directory path that makes sense on your operating system..
$fbCache->AddRoot("C:/fbCache");

# This example assumes a previously obtained an access token
$oauth2 = chilkat::CkOAuth2->new();
$oauth2->put_AccessToken("FACEBOOK-ACCESS-TOKEN");

$rest = chilkat::CkRest->new();

# Connect to Facebook.
$success = $rest->Connect("graph.facebook.com",443,1,1);
if ($success != 1) {
    print $rest->lastErrorText() . "\r\n";
    exit;
}

# Provide the authentication credentials (i.e. the access key)
$rest->SetAuthOAuth2($oauth2);

# There are two choices:  
# We can choose to download the photos the person is tagged in or has uploaded
# by setting type to "tagged" or "uploaded".
$rest->AddQueryParam("type","uploaded");

# To download all photos, we begin with an outer loop that iterates over
# the list of photo nodes in pages.  Each page returned contains a list of 
# photo node ids.  Each photo node id must be retrieved to get the download URL(s)
# of the actual image.

# I don't know the max limit for the number of records that can be downloaded at once.
$rest->AddQueryParam("limit","100");

# Get the 1st page of photos ids.
# See https://developers.facebook.com/docs/graph-api/reference/user/photos/ for more information.
$responseJson = $rest->fullRequestNoBody("GET","/v2.7/me/photos");
if ($rest->get_LastMethodSuccess() != 1) {
    print $rest->lastErrorText() . "\r\n";
    exit;
}

$photoJson = chilkat::CkJsonObject->new();
$saPhotoUrls = chilkat::CkStringArray->new();
$sbPhotoIdPath = chilkat::CkStringBuilder->new();

$json = chilkat::CkJsonObject->new();
$json->put_EmitCompact(0);
$json->Load($responseJson);

# Get the "after" cursor.
$afterCursor = $json->stringOf("paging.cursors.after");
while ($json->get_LastMethodSuccess() == 1) {

    print "-------------------" . "\r\n";
    print "afterCursor = " . $afterCursor . "\r\n";

    # For each photo id in this page...
    $i = 0;
    $numItems = $json->SizeOfArray("data");
    while ($i < $numItems) {
        $json->put_I($i);
        $photoId = $json->stringOf("data[i].id");
        print "photoId = " . $photoId . "\r\n";

        # We need to fetch the JSON for this photo.  Check to see if it's in the local disk cache,
        # and if not, then get it from Facebook.
        $photoJsonStr = $fbCache->fetchText($photoId);
        if ($fbCache->get_LastMethodSuccess() == 0) {
            # It's not locally available, so get it from Facebook..
            $sbPhotoIdPath->Clear();
            $sbPhotoIdPath->Append("/v2.7/");
            $sbPhotoIdPath->Append($photoId);

            $rest->ClearAllQueryParams();
            $rest->AddQueryParam("fields","id,album,images");

            print "Fetching photo node from Facebook..." . "\r\n";

            # This REST request will continue using the existing connection.
            # If the connection was closed, it will automatically reconnect to send the request.
            $photoJsonStr = $rest->fullRequestNoBody("GET",$sbPhotoIdPath->getAsString());
            if ($rest->get_LastMethodSuccess() != 1) {
                print $rest->lastErrorText() . "\r\n";
                exit;
            }

            # Add the photo JSON to the local cache.
            $fbCache->SaveTextNoExpire($photoId,"",$photoJsonStr);
        }

        # Parse the photo JSON and add the main photo download URL to saPhotoUrls
        # There may be multiple URLs in the images array, but the 1st one is the largest and main photo URL.
        # The others are smaller sizes of the same photo.
        $photoJson->Load($photoJsonStr);
        $imageUrl = $photoJson->stringOf("images[0].source");
        if ($photoJson->get_LastMethodSuccess() == 1) {

            # Actually, we'll add a small JSON document that contains both the image ID and the URL.
            $imgUrlJson = chilkat::CkJsonObject->new();
            $imgUrlJson->AppendString("id",$photoId);
            $imgUrlJson->AppendString("url",$imageUrl);
            $saPhotoUrls->Append($imgUrlJson->emit());
            print "imageUrl = " . $imageUrl . "\r\n";
        }

        $i = $i + 1;
    }

    # Prepare for getting the next page of photos ids.
    # We can continue using the same REST object.
    # If already connected, we'll continue using the existing connection.
    # Otherwise, a new connection will automatically be made if needed.
    $rest->ClearAllQueryParams();
    $rest->AddQueryParam("type","uploaded");
    $rest->AddQueryParam("limit","20");
    $rest->AddQueryParam("after",$afterCursor);

    # Get the next page of photo ids.
    $responseJson = $rest->fullRequestNoBody("GET","/v2.7/me/photos");
    if ($rest->get_LastMethodSuccess() != 1) {
        print $rest->lastErrorText() . "\r\n";
        exit;
    }

    $json->Load($responseJson);
    $afterCursor = $json->stringOf("paging.cursors.after");
}

print "No more pages of photos." . "\r\n";

# Now iterate over the photo URLs and download each to a file.
# We can use Chilkat HTTP.  No Facebook authorization (access token) is required to download
# the photo once the URL is known.  
$http = chilkat::CkHttp->new();

# We'll cache the image data so that if run again, we don't re-download the same image again.
$numUrls = $saPhotoUrls->get_Count();
$i = 0;
$urlJson = chilkat::CkJsonObject->new();
$imageBytes = chilkat::CkByteData->new();
$fac = chilkat::CkFileAccess->new();

while ($i < $numUrls) {
    $urlJson->Load($saPhotoUrls->getString($i));
    $photoId = $urlJson->stringOf("id");
    $imageUrl = $urlJson->stringOf("url");

    # Check the local cache for the image data.
    # Only download and save if not already cached.
    $success = $fbCache->FetchFromCache($imageUrl,$imageBytes);
    if ($fbCache->get_LastMethodSuccess() == 0) {
        #  This photo needs to be downloaded.

        $sbImageUrl = chilkat::CkStringBuilder->new();
        $sbImageUrl->Append($imageUrl);

        # Let's form a filename..
        $extension = ".jpg";
        if ($sbImageUrl->Contains(".gif",0) == 1) {
            $extension = ".gif";
        }

        if ($sbImageUrl->Contains(".png",0) == 1) {
            $extension = ".png";
        }

        if ($sbImageUrl->Contains(".tiff",0) == 1) {
            $extension = ".tiff";
        }

        if ($sbImageUrl->Contains(".bmp",0) == 1) {
            $extension = ".bmp";
        }

        $sbLocalFilePath = chilkat::CkStringBuilder->new();
        $sbLocalFilePath->Append("C:/Photos/facebook/uploaded/");
        $sbLocalFilePath->Append($photoId);
        $sbLocalFilePath->Append($extension);

        $success = $http->QuickGet($imageUrl,$imageBytes);
        if ($http->get_LastMethodSuccess() != 1) {
            print $http->lastErrorText() . "\r\n";
            exit;
        }

        # We've downloaded the photo image bytes into memory.
        # Save it to the cache AND save it to the output file.
        $fbCache->SaveToCacheNoExpire($imageUrl,"",$imageBytes);
        $fac->WriteEntireFile($sbLocalFilePath->getAsString(),$imageBytes);

        print "Downloaded to " . $sbLocalFilePath->getAsString() . "\r\n";
    }

    $i = $i + 1;
}

print "Finished downloading all Facebook photos!" . "\r\n";