Rechercher et appliquer des filtres

Champs d'application des autorisations requis

L'API Library de Google Photos contient plusieurs champs d'application permettant d'accéder aux éléments multimédias et aux albums. Les éléments multimédias renvoyés à partir de divers appels varient selon les champs d'application demandés par le développeur.

Le champ d'application photoslibrary.readonly permet d'accéder à tous les éléments multimédias de la bibliothèque de l'utilisateur. Le champ d'application photoslibrary.readonly.appcreateddata autorise uniquement l'accès aux éléments multimédias créés par l'application. Pour en savoir plus, consultez la section Champs d'application des autorisations.

Filtres disponibles

Vous pouvez rechercher des types de fichiers multimédias spécifiques dans la bibliothèque d'un utilisateur. Par exemple, vous pouvez décider d'exclure uniquement les photos d'animaux correspondant à une certaine date, ou d'exclure des photos de reçus. Vous pouvez exclure ou inclure des éléments spécifiques en appliquant des filtres à un album ou à une bibliothèque. Cinq filtres sont disponibles en fonction des propriétés des éléments multimédias:

• Catégories de contenu (includedContentCategories, excludedContentCategories)
• Dates et plages de dates (dates, ranges)
• Fonctionnalités (featureFilter)
• Types de support (mediaTypeFilter)
• État archivé (includeArchivedMedia)

Les filtres ne doivent pas être utilisés dans une requête mediaItems:search si albumId est défini. Si un filtre est utilisé lorsque l'identifiant de l'album est défini, une erreur INVALID_ARGUMENT (400) est renvoyée.

Les résultats sont triés en fonction de l'heure de création de l'élément multimédia. Vous pouvez modifier l'ordre de tri pour les requêtes utilisant des filtres de date.

Patientez un certain temps avant que les nouveaux contenus importés n'apparaissent dans vos recherches. Le contenu multimédia s'affiche immédiatement dans les résultats de recherche non filtrés.

Les éléments multimédias dont la date est située dans le futur n'apparaissent pas dans les résultats de recherche filtrés. Elles apparaissent dans les résultats des recherches non filtrées et dans les albums.

Appliquer un filtre

Pour appliquer un filtre, appelez mediaItems.search et spécifiez la propriété filter.

REST

Voici une requête POST:

POST https://photoslibrary.googleapis.com/v1/mediaItems:search
Content-type: application/json
Authorization: Bearer oauth2-token
{
  "pageSize": "100",
  "filters": {
    ...
  }
}

La requête POST renvoie la réponse suivante:

{
  "mediaItems": [
    ...
  ],
  "nextPageToken": "token-for-pagination"
}

Java

try {
  // Create a new Filter object
  Filters filters = Filters.newBuilder()
      // .setContentFilter(...)
      // .setDateFilter(...)
      // ...
      .build();

  // Specify the Filter object in the searchMediaItems call
  SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);
  for (MediaItem item : response.iterateAll()) {
    // ...
  }
} catch (ApiException e) {
  // Handle error
}

PHP

try {
    $filtersBuilder = new FiltersBuilder();
    // $filtersBuilder->addIncludedCategory(...);
    // $filtersBuilder->addDate(...);
    // ...
    // Make a search call with the options set in the filters builder
    $response = $photosLibraryClient->searchMediaItems(
        ['filters' => $filtersBuilder->build()]
    );
    foreach ($response->iterateAllElements() as $element) {
        // ...
    }
} catch (\Google\ApiCore\ApiException $e) {
    // Handle error
}

Pour en savoir plus, consultez Répertorier le contenu de la bibliothèque, les albums et les éléments multimédias.

Catégories de contenu

Tous les éléments multimédias sont traités et les libellés leur sont attribués. Vous pouvez inclure et exclure l'une des catégories suivantes.

ANIMALS	FASHION	LANDMARKS	RECEIPTS	WEDDINGS
ARTS	FLOWERS	LANDSCAPES	SCREENSHOTS	WHITEBOARDS
BIRTHDAYS	FOOD	NIGHT	SELFIES
CITYSCAPES	GARDENS	PEOPLE	SPORT
CRAFTS	HOLIDAYS	PERFORMANCES	TRAVEL
DOCUMENTS	HOUSES	PETS	UTILITY

Les photos des services publics couvrent un large éventail de supports. Cette catégorie inclut généralement les éléments que l'utilisateur a capturés pour effectuer une tâche et qu'il est peu probable qu'il veuille après avoir terminé. Il peut s'agir de documents, de reçus, de captures d'écran, de notes, de menus et d'autres éléments multimédias similaires.

Les catégories sont aussi précises que les libellés équivalents dans Google Photos. Il arrive que des libellés soient associés à des libellés incorrects. Par conséquent, nous ne pouvons pas garantir l'exactitude des filtres de catégorie de contenu.

Catégories incluses

Lorsque vous incluez plusieurs catégories, les éléments multimédias correspondant à n'importe laquelle des catégories sont inclus. Vous ne pouvez pas inclure plus de 10 catégories par demande. Cet exemple de filtre renvoie tous les éléments de LANDSCAPES ou de LANDMARKS.

REST

{
  "filters": {
    "contentFilter": {
      "includedContentCategories": [
        "LANDSCAPES",
        "LANDMARKS"
      ]
    }
  }
}

Java

// Create a content filter that includes landmarks and landscapes
ContentFilter contentFilter = ContentFilter.newBuilder()
    .addIncludedContentCategories(ContentCategory.LANDMARKS)
    .addIncludedContentCategories(ContentCategory.LANDSCAPES)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setContentFilter(contentFilter)
    .build();
// Specify the Filter object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a content filter that includes landmarks and landscapes
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->addIncludedCategory(ContentCategory::LANDMARKS);
$filtersBuilder->addIncludedCategory(ContentCategory::LANDSCAPES);
// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Catégories exclues

Seuls les éléments multimédias qui ne correspondent à aucune des catégories exclues sont affichés. Comme pour les catégories incluses, 10 catégories au maximum peuvent être exclues par requête.

Ce filtre renvoie tous les éléments autres que PEOPLE ou SELFIES:

REST

{
  "filters": {
    "contentFilter": {
      "excludedContentCategories": [
        "PEOPLE",
        "SELFIES"
      ]
    }
  }
}

Java

// Create a content filter that excludes people and selfies
ContentFilter contentFilter = ContentFilter.newBuilder()
    .addExcludedContentCategories(ContentCategory.PEOPLE)
    .addExcludedContentCategories(ContentCategory.SELFIES)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setContentFilter(contentFilter)
    .build();
// Specify the Filter object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a content filter that excludes people and selfies
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->addExcludedCategory(ContentCategory::PEOPLE);
$filtersBuilder->addExcludedCategory(ContentCategory::SELFIES);
// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Inclure et exclure plusieurs catégories

Vous pouvez inclure certaines catégories et en exclure d'autres. L'exemple suivant renvoie les champs LANDSCAPES et LANDMARKS, mais supprime tous les éléments multimédias contenant PEOPLE ou SELFIES:

REST

{
  "filters": {
    "contentFilter": {
      "includedContentCategories": [
        "LANDSCAPES",
        "LANDMARKS"
      ],
      "excludedContentCategories": [
        "PEOPLE",
        "SELFIES"
      ]
    }
  }
}

Java

// Create a content filter that excludes people and selfies and includes landmarks and landscapes
ContentFilter contentFilter = ContentFilter.newBuilder()
    .addIncludedContentCategories(ContentCategory.LANDSCAPES)
    .addIncludedContentCategories(ContentCategory.LANDMARKS)
    .addExcludedContentCategories(ContentCategory.PEOPLE)
    .addExcludedContentCategories(ContentCategory.SELFIES)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setContentFilter(contentFilter)
    .build();
// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a content filter that excludes people and selfies and includes landmarks and landscapes
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->addIncludedCategory(ContentCategory::LANDMARKS);
$filtersBuilder->addIncludedCategory(ContentCategory::LANDSCAPES);
$filtersBuilder->addExcludedCategory(ContentCategory::PEOPLE);
$filtersBuilder->addExcludedCategory(ContentCategory::SELFIES);
// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Dates et plages de dates

Les filtres de date limitent la date des résultats renvoyés à un ensemble de jours spécifié. Il existe deux façons de spécifier un filtre de date: les dates ou les plages. Les dates et les plages peuvent être utilisées ensemble. Les éléments multimédias correspondant à n'importe quelle date ou plage de dates sont renvoyés. Vous pouvez éventuellement modifier l'ordre de tri des résultats.

Remarque :Les éléments multimédias importés sans métadonnées spécifiant la date de capture de l'élément multimédia ne seront pas renvoyés dans les requêtes utilisant des filtres de date. Dans ce cas, l'heure d'importation du serveur Google Photos n'est pas utilisée en remplacement.

Dates

Une date contient une année, un mois et un jour. Les formats suivants sont acceptés:

• Year
• Année, mois
• Année, mois, jour
• Mois, jour
• Mois

Lorsqu'un composant de la date est vide ou défini sur zéro, il est considéré comme un caractère générique. Par exemple, si vous définissez le jour et le mois, mais pas l'année, vous demandez les éléments de ce jour et de ce mois:

REST

{
  "filters": {
    "dateFilter": {
      "dates": [
        {
          "month": 2,
          "day": 15
        }
      ]
    }
  }
}

Java

// Create a new com.google.type.Date object using a builder
// Note that there are different valid combinations as described above
Date dayFebruary15 = Date.newBuilder()
    .setDay(15)
    .setMonth(2)
    .build();
// Create a new dateFilter. You can also set multiple dates here
DateFilter dateFilter = DateFilter.newBuilder()
    .addDates(dayFebruary15)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setDateFilter(dateFilter)
    .build();
// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new Google\Type\Date object with a day and a month
// Note that there are different valid combinations as described above
$dateFebruary15 = new Date();
$dateFebruary15->setDay(15);
$dateFebruary15->setMonth(2);
$filtersBuilder = new FiltersBuilder();
// Add the date to the filter. You can also set multiple dates here
$filtersBuilder->addDate($dateFebruary15);
// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Plages de dates

Les plages de dates offrent plus de flexibilité que les dates. Par exemple, plutôt que d'ajouter plusieurs dates, vous pouvez utiliser une plage de dates pour afficher un ensemble de jours dans un mois.

Une plage de dates comporte des startDate et des endDate, qui doivent être définis. Chaque date de la plage présente les mêmes contraintes de format que celles décrites dans la section Dates. Les dates doivent avoir le même format: si la date de début est une année et un mois, la date de fin doit également être une année et un mois. Les plages sont appliquées de manière inclusive : les dates de début et de fin sont incluses dans le filtre appliqué :

REST

{
  "filters": {
    "dateFilter": {
      "ranges": [
        {
          "startDate": {
            "year": 2014,
            "month": 6,
            "day": 12
          },
          "endDate": {
            "year": 2014,
            "month": 7,
            "day": 13
          }
        }
      ]
    }
  }
}

Java

// Create new com.google.type.Date objects for two dates
Date day2014June12 = Date.newBuilder()
    .setDay(12)
    .setMonth(6)
    .setYear(2014)
    .build();
Date day2014July13 = Date.newBuilder()
    .setDay(13)
    .setMonth(7)
    .setYear(2014)
    .build();
// Create a DateRange from these two dates
DateRange dateRange = DateRange.newBuilder()
    .setStartDate(day2014June12)
    .setEndDate(day2014July13)
    .build();
// Create a new dateFilter with the date range. You can also set multiple date ranges here
DateFilter dateFilter = DateFilter.newBuilder()
    .addRanges(dateRange)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setDateFilter(dateFilter)
    .build();
// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create two new Google\Type\Date objects
    $date2014June12 = new Date();
    $date2014June12->setDay(12);
    $date2014June12->setMonth(6);
    $date2014June12->setYear(2014);

    $date2014July13 = new Date();
    $date2014July13->setDay(13);
    $date2014July13->setMonth(7);
    $date2014July13->setYear(2014);

    // Add the two dates as a date range to the filter
    // You can also set multiple date ranges here
    $filtersBuilder = new FiltersBuilder();
    $filtersBuilder->addDateRange($date2014June12, $date2014July13);

    // Make a search call with the options set in the filters builder
    $response = $photosLibraryClient->searchMediaItems(
        ['filters' => $filtersBuilder->build()]
    );

Combiner des dates et des plages de dates

Vous pouvez utiliser plusieurs dates et plages de dates en même temps. Les éléments qui correspondent à l'une de ces dates sont inclus dans les résultats. Les dates distinctes et les plages de dates ne doivent pas nécessairement suivre le même format. En revanche, les dates de début et de fin de plages individuelles le sont:

REST

{
  "filters": {
    "dateFilter": {
      "dates": [
        {
          "year": 2013
        },
        {
          "year": 2011,
          "month": 11
        }
      ],
      "ranges": [
        {
          "startDate": {
            "month": 1
          },
          "endDate": {
            "month": 3
          }
        },
        {
          "startDate": {
            "month": 3,
            "day": 24
          },
          "endDate": {
            "month": 5,
            "day": 2
          }
        }
      ]
    }
  }
}

Java

// Create a new com.google.type.Date object for the year 2013
Date day2013 = Date.newBuilder()
    .setYear(2013)
    .build();
// Create a new com.google.type.Date object for November 2011
Date day2011November = Date.newBuilder()
    .setMonth(11)
    .setYear(2011)
    .build();
// Create a date range for January to March
DateRange dateRangeJanuaryToMarch = DateRange.newBuilder()
    .setStartDate(Date.newBuilder().setMonth(1).build())
    .setEndDate(Date.newBuilder().setMonth(3).build())
    .build();
// Create a date range for March 24 to May 2
DateRange dateRangeMarch24toMay2 = DateRange.newBuilder()
    .setStartDate(Date.newBuilder().setMonth(3).setDay(24).build())
    .setEndDate(Date.newBuilder().setMonth(5).setDay(2).build())
    .build();
// Create a new dateFilter with the dates and date ranges
DateFilter dateFilter = DateFilter.newBuilder()
    .addDates(day2013)
    .addDates(day2011November)
    .addRanges(dateRangeJanuaryToMarch)
    .addRanges(dateRangeMarch24toMay2)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setDateFilter(dateFilter)
    .build();
// Specify the Filter object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new Google\Type\Date object for the year 2013
$date2013 = new Date();
$date2013->setYear(2013);

// Create a new Google\Type\Date object for November 2011
$dateNovember2011 = new Date();
$dateNovember2011->setMonth(11);
$dateNovember2011->setYear(2011);

$filtersBuilder = new FiltersBuilder();

// Create a date range for January to March
$filtersBuilder->addDateRange((new Date())->setMonth(1),
    (new Date())->setMonth(3));

// Create a date range for March 24 to May 2
$filtersBuilder->addDateRange((new Date())->setMonth(3)->setDay(24),
    (new Date())->setMonth(5)->setDay(2));

$filtersBuilder->addDate($date2013);
$filtersBuilder->addDate($dateNovember2011);

// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Fonctionnalités des éléments multimédias

Les filtres de caractéristiques limitent les résultats aux éléments qui ont des caractéristiques spécifiques, par exemple qui ont été marqués comme favoris dans l'application Google Photos.

Favoris

Incluez la fonctionnalité d'élément FAVORITES dans la FeatureFilter pour ne renvoyer que les éléments multimédias marqués comme favoris par l'utilisateur:

REST

{
  "filters" : {
    "featureFilter": {
      "includedFeatures": [
        "FAVORITES"
      ]
    }
  }
}

Java

// Create a new FeatureFilter for favorite media items
FeatureFilter featureFilter = FeatureFilter.newBuilder()
    .addIncludedFeatures(Feature.FAVORITES)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setFeatureFilter(featureFilter)
    .build();
// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new FeatureFilter for favorite media items
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->addIncludedFeature(Feature::FAVORITES);

// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Types de contenu

Vous pouvez limiter les résultats au type de support: photo ou vidéo.

Photo

Un PHOTO peut correspondre à l'un des formats d'image suivants:

BMP	JPG
GIF	PNG
HEIC	TIFF
ICO	WEBP

Il inclut également des types de photos spéciaux tels que des photos instantanées en direct, des photos animées, des panoramas, des photo-sphères et des photos RV.

Vidéo

Un VIDEO peut se présenter sous différents formats vidéo:

3GP	VMM
3G2.	MOD
ASF	MOV
AVI	MP4
DIVX	MPG
M2T	MTS
M2TS.	TOD
M4 v	WMV
MKV

VIDEO inclut également des formats vidéo spéciaux tels que les vidéos de réalité virtuelle, les ralentis et les animations créées dans l'application Google Photos.

L'exemple suivant filtre par PHOTO:

REST

{
  "filters": {
    "mediaTypeFilter": {
      "mediaTypes": [
        "PHOTO"
      ]
    }
  }
}

Java

// Create a new MediaTypeFilter for Photo media items
MediaTypeFilter mediaType = MediaTypeFilter.newBuilder()
    .addMediaTypes(MediaType.PHOTO)
    .build();
// Create a new Filters object
Filters filters = Filters.newBuilder()
    .setMediaTypeFilter(mediaType)
    .build();
// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new MediaTypeFilter for Photo media items
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->setMediaType(MediaType::PHOTO);

// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Impossible de combiner plusieurs filtres de types de support.

Exclure les données non créées pour une appli

Pour exclure les éléments multimédias qui n'ont pas été créés par votre application, vous pouvez définir le filtre excludeNonAppCreatedData comme indiqué dans l'exemple suivant:

REST

{
  "filters": {
    "excludeNonAppCreatedData": true
  }
}

Java

// Create a new Filters object that excludes media not created by your app
Filters filters = Filters.newBuilder()
    .setExcludeNonAppCreatedData(true)
    .build();

// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new Filters object that excludes media not created by your app
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->setExcludeNonAppCreatedData(true);

// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Notez que si vous utilisez le champ d'application .readonly.appcreateddata, ce filtre est ignoré.

État archivé

Vos utilisateurs ont peut-être archivé certaines de leurs photos. Par défaut, les photos archivées ne sont pas renvoyées lors des recherches. Pour inclure des éléments archivés, vous pouvez définir une option dans le filtre comme illustré dans l'exemple suivant:

REST

{
  "filters": {
    "includeArchivedMedia": true
  }
}

Java

// Create a new Filters object that includes archived media
Filters filters = Filters.newBuilder()
    .setIncludeArchivedMedia(true)
    .build();

// Specify the Filters object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new Filters object that includes archived media
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->setIncludeArchivedMedia(true);

// Make a search call with the options set in the filters builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Combiner des filtres

Différents types de filtres peuvent être combinés. Seuls les éléments qui correspondent à toutes les caractéristiques demandées sont renvoyés.

Lorsque vous combinez des filtres, les restrictions de mise en forme de chaque type de filtre sont identiques à celles utilisées individuellement. Dans l'exemple suivant, seules les photos de la catégorie SPORT 2014 ou 2010 sont renvoyées:

REST

{
  "filters": {
    "contentFilter": {
      "includedContentCategories": [
        "SPORT"
      ]
    },
    "dateFilter": {
      "dates": [
        {
          "year": 2014
        },
        {
          "year": 2010
        }
      ]
    },
    "mediaTypeFilter": {
      "mediaTypes": [
        "PHOTO"
      ]
    }
  }
}

Java

// Create a new ContentFilter that only includes SPORT items
ContentFilter contentFilter = ContentFilter.newBuilder()
    .addIncludedContentCategories(ContentCategory.SPORT)
    .build();
// Create a new media type filter that only includes PHOTO media items
MediaTypeFilter mediaTypeFilter = MediaTypeFilter.newBuilder()
    .addMediaTypes(MediaType.PHOTO)
    .build();
// Create a new DateFilter that only includes items from 2010 or 2014
Date year2014 = Date.newBuilder().setYear(2014).build();
Date year2010 = Date.newBuilder().setYear(2010).build();
DateFilter dateFilter = DateFilter.newBuilder()
    .addDates(year2010)
    .addDates(year2014)
    .build();
// Create a new Filters object combining these filters
Filters filters = Filters.newBuilder()
    .setDateFilter(dateFilter)
    .setMediaTypeFilter(mediaTypeFilter)
    .setContentFilter(contentFilter)
    .build();
// Specify the Filter object in the searchMediaItems call
SearchMediaItemsPagedResponse response = photosLibraryClient.searchMediaItems(filters);

PHP

// Create a new ContentFilter
$filtersBuilder = new FiltersBuilder();
// Only include SPORT items
$filtersBuilder->addIncludedCategory(ContentCategory::SPORT);
// Only include PHOTO media items
$filtersBuilder->setMediaType(MediaType::PHOTO);
// Only include items from 2010 or 2014
$year2014 = new Date();
$year2014->setYear(2014);
$year2010 = new Date();
$year2010->setYear(2010);
$filtersBuilder->addDateRange($year2010, $year2014);

// Make a search call with the options set in the filters builder
// Filters have been combined in the filter builder
$response = $photosLibraryClient->searchMediaItems(
    ['filters' => $filtersBuilder->build()]
);

Tri des résultats

Seules les requêtes utilisant des filtres de date peuvent être triées.

Si vous ne spécifiez pas d'option de tri, les résultats sont triés par ordre décroissant (les plus récents d'abord).

Ce tableau présente les options compatibles avec le paramètre orderBy:

Paramètre orderBy
MediaMetadata.creation_time desc	Affiche les éléments multimédias par ordre décroissant (les éléments les plus récents en premier)
MediaMetadata.creation_time	Affiche les éléments multimédias par ordre croissant (les plus anciens en premier)

L'exemple suivant renvoie tous les éléments multimédias de 2017, en affichant le plus ancien en premier.

REST

{
  "filters": {
    "dateFilter": {
      "dates": [
        {
          "year": 2017
        }
      ]
    }
  },
  "orderBy": "MediaMetadata.creation_time"
}

Java

// Create a new dateFilter for the year 2017.
DateFilter dateFilter = DateFilter.newBuilder()
        .addDates(Date.newBuilder().setYear(2017))
        .build();

// Create a new Filters object
Filters filters = Filters.newBuilder()
        .setDateFilter(dateFilter)
        .build();

// Sort results by oldest item first.
final OrderBy newestFirstOrder = OrderBy.MEDIAMETADATA_CREATION_TIME;

// Specify the filter and sort order in the searchMediaItems call.
SearchMediaItemsPagedResponse response
        = photosLibraryClient.searchMediaItems(filters, newestFirstOrder);

PHP

// Create a new dateFilter for the year 2017.
$filtersBuilder = new FiltersBuilder();
$filtersBuilder->addDate((new Date())->setYear(2017));

// Make a search call with the options set in the filters builder and sort
// the results by oldest item first.
$response = $photosLibraryClient->searchMediaItems(
    [
        'filters' => $filtersBuilder->build(),
        'orderBy' => OrderBy::MEDIAMETADATA_CREATION_TIME
    ]
);