Dart

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. Dart

import 'dart:typed_data';

import 'package:chilkat/chilkat.dart';

void main() {
  // 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.
  final fbCache = CkCache();
  // 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
  final oauth2 = CkOAuth2();
  oauth2.accessToken = 'FACEBOOK-ACCESS-TOKEN';

  final rest = CkRest();

  // Connect to Facebook.
  try {
    rest.connect('graph.facebook.com', 443, true, true);
  } on ChilkatException catch (e) {
    print(e.lastErrorText);
    return;
  }

  // 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.
  String responseJson;
  try {
    responseJson = rest.fullRequestNoBody('GET', '/v2.7/me/photos');
  } on ChilkatException catch (e) {
    print(e.lastErrorText);
    return;
  }

  final photoJson = CkJsonObject();
  final saPhotoUrls = CkStringArray();
  final sbPhotoIdPath = CkStringBuilder();

  final json = CkJsonObject();
  json.emitCompact = false;
  json.load(responseJson);

  var i = 0;
  var photoId = '';
  var imageUrl = '';

  // Get the "after" cursor.
  var afterCursor = json.stringOf('paging.cursors.after');
  while (json.lastMethodSuccess) {

    print('-------------------');
    print('afterCursor = $afterCursor');

    // For each photo id in this page...
    i = 0;
    final numItems = json.sizeOfArray('data');
    while (i < numItems) {
      json.i = i;
      photoId = json.stringOf('data[i].id');
      print('photoId = $photoId');

      // 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.
      var photoJsonStr = '';
      try {
        photoJsonStr = fbCache.fetchText(photoId);
      } on ChilkatException {
        // 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...');

        // This REST request will continue using the existing connection.
        // If the connection was closed, it will automatically reconnect to send the request.
        try {
          photoJsonStr = rest.fullRequestNoBody('GET', sbPhotoIdPath.getAsString());
        } on ChilkatException catch (e) {
          print(e.lastErrorText);
          return;
        }

        // 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);
      try {
        imageUrl = photoJson.stringOf('images[0].source');

        // Actually, we'll add a small JSON document that contains both the image ID and the URL.
        final imgUrlJson = CkJsonObject();
        imgUrlJson.appendString('id', photoId);
        imgUrlJson.appendString('url', imageUrl);
        saPhotoUrls.append(imgUrlJson.emit());
        print('imageUrl = $imageUrl');
      } on ChilkatException {
        // photoJson.stringOf() failed; continue anyway.
      }

      i++;
    }

    // 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.
    try {
      responseJson = rest.fullRequestNoBody('GET', '/v2.7/me/photos');
    } on ChilkatException catch (e) {
      print(e.lastErrorText);
      return;
    }

    json.load(responseJson);
    afterCursor = json.stringOf('paging.cursors.after');
  }

  print('No more pages of photos.');

  // 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.  
  final http = CkHttp();

  // We'll cache the image data so that if run again, we don't re-download the same image again.
  final numUrls = saPhotoUrls.count;
  i = 0;
  final urlJson = CkJsonObject();
  var imageBytes = Uint8List(0);
  final fac = CkFileAccess();

  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) {
      //  This photo needs to be downloaded.

      final sbImageUrl = CkStringBuilder();
      sbImageUrl.append(imageUrl);

      // Let's form a filename..
      var extensionVar = '.jpg';
      if (sbImageUrl.contains('.gif', false)) {
        extensionVar = '.gif';
      }

      if (sbImageUrl.contains('.png', false)) {
        extensionVar = '.png';
      }

      if (sbImageUrl.contains('.tiff', false)) {
        extensionVar = '.tiff';
      }

      if (sbImageUrl.contains('.bmp', false)) {
        extensionVar = '.bmp';
      }

      final sbLocalFilePath = CkStringBuilder();
      sbLocalFilePath.append('C:/Photos/facebook/uploaded/');
      sbLocalFilePath.append(photoId);
      sbLocalFilePath.append(extensionVar);

      imageBytes = http.quickGet(imageUrl);
      if (!http.lastMethodSuccess) {
        print(http.lastErrorText);
        return;
      }

      // 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()}');
    }

    i++;
  }

  print('Finished downloading all Facebook photos!');
}