PHP ActiveX

Facebook Download all Photos to Local Files

See more Facebook Examples

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. PHP ActiveX

<?php

$success = 0;

// 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 = new COM("Chilkat.Cache");
// The cache will use 1 level of 256 sub-directories.
$fbCache->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 = new COM("Chilkat.OAuth2");
$oauth2->AccessToken = 'FACEBOOK-ACCESS-TOKEN';

$rest = new COM("Chilkat.Rest");

// Connect to Facebook.
$success = $rest->Connect('graph.facebook.com',443,1,1);
if ($success != 1) {
    print $rest->LastErrorText . "\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->LastMethodSuccess != 1) {
    print $rest->LastErrorText . "\n";
    exit;
}

$photoJson = new COM("Chilkat.JsonObject");
$saPhotoUrls = new COM("Chilkat.StringArray");
$sbPhotoIdPath = new COM("Chilkat.StringBuilder");

$json = new COM("Chilkat.JsonObject");
$json->EmitCompact = 0;
$json->Load($responseJson);

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

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

    // For each photo id in this page...
    $i = 0;
    $numItems = $json->SizeOfArray('data');
    while ($i < $numItems) {
        $json->I = $i;
        $photoId = $json->stringOf('data[i].id');
        print 'photoId = ' . $photoId . "\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->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...' . "\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->LastMethodSuccess != 1) {
                print $rest->LastErrorText . "\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->LastMethodSuccess == 1) {

            // Actually, we'll add a small JSON document that contains both the image ID and the URL.
            $imgUrlJson = new COM("Chilkat.JsonObject");
            $imgUrlJson->AppendString('id',$photoId);
            $imgUrlJson->AppendString('url',$imageUrl);
            $saPhotoUrls->Append($imgUrlJson->emit());
            print 'imageUrl = ' . $imageUrl . "\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->LastMethodSuccess != 1) {
        print $rest->LastErrorText . "\n";
        exit;
    }

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

print 'No more pages of photos.' . "\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 = new COM("Chilkat.Http");

// We'll cache the image data so that if run again, we don't re-download the same image again.
$numUrls = $saPhotoUrls->Count;
$i = 0;
$urlJson = new COM("Chilkat.JsonObject");

$fac = new COM("Chilkat.FileAccess");

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.
    $imageBytes = $fbCache->FetchFromCache($imageUrl);
    if ($fbCache->LastMethodSuccess == 0) {
        //  This photo needs to be downloaded.

        $sbImageUrl = new COM("Chilkat.StringBuilder");
        $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 = new COM("Chilkat.StringBuilder");
        $sbLocalFilePath->Append('C:/Photos/facebook/uploaded/');
        $sbLocalFilePath->Append($photoId);
        $sbLocalFilePath->Append($extension);

        $imageBytes = $http->QuickGet($imageUrl);
        if ($http->LastMethodSuccess != 1) {
            print $http->LastErrorText . "\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() . "\n";
    }

    $i = $i + 1;
}

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

?>