React Native

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. React Native

import { Cache, FileAccess, Http, JsonObject, OAuth2, Rest, StringArray, StringBuilder } from '@chilkat/react-native'

async function chilkatExample() {
  // 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.
  const fbCache = new 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
  const oauth2 = new OAuth2();
  oauth2.accessToken = 'FACEBOOK-ACCESS-TOKEN';

  const rest = new Rest();

  // Connect to Facebook.
  try {
    await rest.connectAsync('graph.facebook.com', 443, true, true);
  } catch {
    console.log(rest.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.
  let responseJson: string;
  try {
    responseJson = await rest.fullRequestNoBodyAsync('GET', '/v2.7/me/photos');
  } catch {
    console.log(rest.lastErrorText);
    return;
  }

  const photoJson = new JsonObject();
  const saPhotoUrls = new StringArray();
  const sbPhotoIdPath = new StringBuilder();

  const json = new JsonObject();
  json.emitCompact = false;
  json.load(responseJson);

  let i = 0;
  let photoId = '';
  let imageUrl = '';

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

    console.log('-------------------');
    console.log(`afterCursor = ${afterCursor}`);

    // For each photo id in this page...
    i = 0;
    const numItems = json.sizeOfArray('data');
    while (i < numItems) {
      json.i = i;
      photoId = json.stringOf('data[i].id');
      console.log(`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.
      let photoJsonStr = '';
      try {
        photoJsonStr = fbCache.fetchText(photoId);
      } catch {
        // 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');

        console.log('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 = await rest.fullRequestNoBodyAsync('GET', sbPhotoIdPath.getAsString());
        } catch {
          console.log(rest.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.
        const imgUrlJson = new JsonObject();
        imgUrlJson.appendString('id', photoId);
        imgUrlJson.appendString('url', imageUrl);
        saPhotoUrls.append(imgUrlJson.emit());
        console.log(`imageUrl = ${imageUrl}`);
      } catch {
        // 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 = await rest.fullRequestNoBodyAsync('GET', '/v2.7/me/photos');
    } catch {
      console.log(rest.lastErrorText);
      return;
    }

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

  console.log('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.  
  const http = new Http();

  // We'll cache the image data so that if run again, we don't re-download the same image again.
  const numUrls = saPhotoUrls.count;
  i = 0;
  const urlJson = new JsonObject();
  let imageBytes = new ArrayBuffer(0);
  const fac = new 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) {
      //  This photo needs to be downloaded.

      const sbImageUrl = new StringBuilder();
      sbImageUrl.append(imageUrl);

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

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

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

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

      const sbLocalFilePath = new StringBuilder();
      sbLocalFilePath.append('C:/Photos/facebook/uploaded/');
      sbLocalFilePath.append(photoId);
      sbLocalFilePath.append(extension);

      imageBytes = await http.quickGetAsync(imageUrl);
      if (!http.lastMethodSuccess) {
        console.log(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);

      console.log(`Downloaded to ${sbLocalFilePath.getAsString()}`);
    }

    i++;
  }

  console.log('Finished downloading all Facebook photos!');
}