Cerca e applica filtri

Ambiti di autorizzazione obbligatori

L'API Libreria Google Foto contiene più ambiti utilizzati per accedere a elementi multimediali e album. Gli elementi multimediali restituiti dalle varie chiamate variano in base agli ambiti richiesti dallo sviluppatore.

L'ambito photoslibrary.readonly consente l'accesso a tutti gli elementi multimediali nella raccolta dell'utente. L'ambito photoslibrary.readonly.appcreateddata consente l'accesso solo agli elementi multimediali creati dall'app. Per ulteriori informazioni, consulta Ambiti di autorizzazione.

Filtri disponibili

Puoi cercare tipi specifici di contenuti multimediali nella raccolta di un utente. Ad esempio, potresti volere solo gli elementi che raffigurano animali di un determinato giorno oppure escludere le foto delle ricevute. Puoi escludere o includere elementi specifici applicando filtri alla scheda di un album o della raccolta. Sono disponibili cinque filtri basati sulle proprietà degli elementi multimediali:

• Categorie di contenuti (includedContentCategories, excludedContentCategories)
• Date e intervalli di date (dates, ranges)
• Funzionalità (featureFilter)
• Tipi di media (mediaTypeFilter)
• Stato archiviato (includeArchivedMedia)

I filtri non devono essere utilizzati in una richiesta mediaItems:search se il valore albumId è impostato. Se viene utilizzato un filtro quando è impostato l'ID album, viene restituito un errore INVALID_ARGUMENT (400).

I risultati vengono ordinati in base all'ora di creazione dell'elemento multimediale. L'ordine di ordinamento può essere modificato per le query utilizzando i filtri della data.

Potrebbe occorrere del tempo per visualizzare i contenuti multimediali appena caricati nelle tue ricerche. I contenuti multimediali vengono visualizzati immediatamente nelle ricerche non filtrate.

Gli elementi multimediali con una data futura non vengono visualizzati nelle ricerche filtrate. Vengono visualizzati nelle ricerche senza filtri e negli album.

Applicazione di un filtro

Per applicare un filtro, chiama mediaItems.search e specifica la proprietà filter.

REST

Ecco una richiesta POST:

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

La richiesta POST restituisce la seguente risposta:

{
  "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
}

Per maggiori dettagli, consulta Elencare contenuti della raccolta, album ed elementi multimediali.

Categorie di contenuti

Tutti gli elementi multimediali vengono elaborati e vengono assegnate etichette. Puoi includere ed escludere una qualsiasi delle seguenti categorie.

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

Le foto di utility coprono una vasta gamma di contenuti multimediali. Questa categoria in genere include gli elementi che l'utente ha acquisito per eseguire un'attività ed è improbabile che vogliano dopo il completamento dell'attività. Include documenti, ricevute, screenshot, note adesive, menu e altri elementi multimediali simili.

Le categorie sono accurate solo quanto le etichette equivalenti in Google Foto. A volte gli articoli potrebbero essere etichettati in modo errato, pertanto non garantiamo l'accuratezza dei filtri per le categorie di contenuti.

Categorie incluse

Quando includi più categorie, vengono inclusi gli elementi multimediali corrispondenti a una qualsiasi delle categorie. È possibile includere un massimo di 10 categorie per richiesta. Questo filtro di esempio restituisce tutti gli elementi di LANDSCAPES o 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()]
);

Esclusione di categorie

Vengono mostrati solo gli elementi multimediali che non corrispondono a nessuna delle categorie escluse. Analogamente alle categorie incluse, è possibile escludere un massimo di 10 categorie per richiesta.

Questo filtro restituisce tutti gli elementi che non sono PEOPLE o 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()]
);

Inclusione ed esclusione di più categorie

Puoi includere alcune categorie ed escluderne altre. L'esempio seguente restituisce LANDSCAPES e LANDMARKS, ma rimuove tutti gli elementi multimediali che contengono PEOPLE o sono 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()]
);

Date e intervalli di date

I filtri per data limitano la data dei risultati restituiti a un insieme specificato di giorni. Esistono due modi per specificare un filtro per data: date o intervalli. Le date e gli intervalli possono essere utilizzati insieme. Vengono restituiti gli elementi multimediali che corrispondono a una qualsiasi delle date o degli intervalli di date. Facoltativamente, puoi modificare l'ordinamento dei risultati.

Nota: gli elementi multimediali caricati senza metadati che specificano la data di acquisizione dell'elemento multimediale non verranno restituiti nelle query che utilizzano i filtri della data. In questo caso, il tempo di caricamento del server di Google Foto non viene utilizzato come riserva.

Date

Una data contiene un anno, un mese e un giorno. Sono accettati i seguenti formati:

• Anno
• Anno, mese
• Anno, mese, giorno
• Mese, giorno
• Mese

Se un componente della data è vuoto o impostato su zero, viene considerato un carattere jolly. Ad esempio, se imposti il giorno e il mese, ma non l'anno, richiedi articoli a partire da quel giorno e mese di qualsiasi anno:

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()]
);

Intervalli di date

Gli intervalli di date offrono una maggiore flessibilità rispetto alle date. Ad esempio, anziché aggiungere più date, è possibile utilizzare un intervallo di date per visualizzare un insieme di giorni in un mese.

Un intervallo di date ha startDate e endDate, che devono essere entrambi impostati. Ogni data nell'intervallo ha gli stessi vincoli di formato descritti in Date. Le date devono avere lo stesso formato: se la data di inizio è un anno e un mese, anche la data di fine deve essere un anno e un mese. Gli intervalli vengono applicati in modo inclusivo, le date di inizio e di fine sono incluse nel filtro applicato:

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()]
    );

Combinazione di date e intervalli di date

Puoi utilizzare più date e intervalli di date contemporaneamente. Gli elementi che rientrano in una di queste date vengono inclusi nei risultati. Date e intervalli di date separati non devono necessariamente seguire lo stesso formato, al contrario delle date di inizio e di fine dei singoli intervalli:

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()]
);

Funzionalità dell'elemento multimediale

I filtri funzionalità limitano i risultati a elementi che dispongono di funzionalità specifiche, ad esempio che sono stati contrassegnati come preferiti nell'applicazione Google Foto.

Preferiti

Includi la funzionalità elemento FAVORITES in FeatureFilter per restituire solo elementi multimediali che sono stati contrassegnati come preferiti dall'utente:

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()]
);

Tipi di contenuti multimediali

Puoi limitare i risultati al tipo di contenuti multimediali: foto o video.

Foto

Un PHOTO può essere uno dei seguenti formati dell'immagine:

BMP	JPG
GIF	PN
HEIC	TIFF
ICO	WEBP

Include inoltre tipi speciali di foto come Live Photo su iOS, foto in movimento, panoramiche, foto sferiche e foto VR.

Video

Un VIDEO può avere vari formati video:

3GP	MMV
3G2	MOD
ASF	MOV
AVI	MP4
DIVX	MPG
M2	MTS
M2T	LUCA
M4V	WMV
MKV

VIDEO include anche formati video speciali come i seguenti: video VR, video in slow motion e animazioni creati nell'applicazione Google Foto.

L'esempio seguente applica un filtro in base a 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()]
);

Non è possibile combinare più filtri di tipi di contenuti multimediali.

Escludi dati creati da app non create

Per escludere gli elementi multimediali che non sono stati creati dalla tua app, puoi impostare il filtro excludeNonAppCreatedData come mostrato nell'esempio seguente:

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()]
);

Tieni presente che se utilizzi l'ambito .readonly.appcreateddata, questo filtro viene ignorato.

Stato archiviato

I tuoi utenti potrebbero aver archiviato alcune delle loro foto. Per impostazione predefinita, le foto archiviate non vengono restituite nelle ricerche. Per includere gli elementi archiviati, puoi impostare un flag nel filtro, come mostrato nell'esempio seguente:

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()]
);

Combinazione di filtri

È possibile combinare diversi tipi di filtri. Vengono restituiti solo gli articoli che corrispondono a tutte le funzionalità richieste.

Quando combini i filtri, le limitazioni di formattazione per ogni tipo di filtro sono le stesse di quando vengono utilizzati singolarmente. Nell'esempio seguente, vengono restituite solo le foto classificate come SPORT e risalenti al 2014 o al 2010:

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()]
);

Ordinamento dei risultati

È possibile ordinare solo le query che utilizzano filtri di data.

Se non specifichi un'opzione di ordinamento, i risultati verranno ordinati in ordine decrescente (dal più recente).

Questa tabella mostra le opzioni supportate per il parametro orderBy:

Parametro orderBy
MediaMetadata.creation_time desc	Restituisce gli elementi multimediali in ordine decrescente (dagli elementi più recenti)
MediaMetadata.creation_time	Restituisce gli elementi multimediali in ordine crescente (dagli elementi meno recenti)

L'esempio seguente restituisce tutti gli elementi multimediali del 2017, mostrando i primi e i più recenti.

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
    ]
);