Suchen und Filter anwenden

Erforderliche Autorisierungsbereiche

Die Google Photos Library API umfasst mehrere Bereiche für den Zugriff auf Medienelemente und Alben. Die von verschiedenen Aufrufen zurückgegebenen Medienelemente unterscheiden sich je nach Umfang vom Entwickler angefordert wurden.

Der Bereich photoslibrary.readonly ermöglicht den Zugriff auf alle Medienelemente im in der Bibliothek des Nutzers. Der Bereich photoslibrary.readonly.appcreateddata ermöglicht Zugriff die von der App erstellt wurden. Weitere Informationen finden Sie unter Autorisierungsbereiche.

Verfügbare Filter

Sie können die Mediathek eines Nutzers nach bestimmten Medientypen durchsuchen. Zum Beispiel haben Sie möchten Sie vielleicht nur Artikel von Tieren, von einem bestimmten Tag um Fotos von Belegen auszuschließen. Sie können bestimmte Artikel ein- oder ausschließen, indem Sie und wenden Filter auf ein Album oder einen Bibliothekseintrag an. Es gibt fünf Filter basierend auf den Eigenschaften der Medienelemente:

In einer mediaItems:search-Anfrage sollten keine Filter verwendet werden, wenn albumId festgelegt. Wird ein Filter verwendet, wenn die albumId festgelegt ist, wird der Fehler INVALID_ARGUMENT angezeigt (400) zurückgegeben.

Die Ergebnisse werden nach der Erstellungszeit der Medienelemente sortiert. Die Die Sortierreihenfolge kann für Abfragen mithilfe von Datumsfiltern geändert werden.

Es kann eine Weile dauern, bis neu hochgeladene Medien in Ihren Suchanfragen angezeigt werden. Die Medien erscheint sofort in den ungefilterten Suchanfragen.

Medienelemente mit einem Datum in der Zukunft werden nicht in den gefilterten Suchanfragen angezeigt. Sie erscheinen in ungefilterten Suchanfragen und Albumsuchen.

Filter anwenden

Um einen Filter anzuwenden, rufen Sie mediaItems.search und Geben Sie die Property filter an.

REST

Hier ist eine POST-Anfrage:

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

Die POST-Anfrage gibt die folgende Antwort zurück:

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

Weitere Informationen finden Sie unter Bibliotheksinhalte, Alben und Medienelemente auflisten

Inhaltskategorien

Alle Medienelemente werden verarbeitet und mit Labels versehen. Sie können ein- und ausschließen, einer der folgenden Kategorien wählen.

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  

Fotos mit nützlichen Informationen decken eine breite Palette von Medien ab. Diese Kategorie umfasst in der Regel Elemente, die Nutzende für eine bestimmte Aufgabe erfasst haben und die sie danach wahrscheinlich nicht mehr benötigen dass diese Aufgabe abgeschlossen ist. Sie enthält Dokumente, Belege, Screenshots, fixierte Notizen, Menüs und anderen ähnlichen Medienelementen.

Die Kategorien sind nur so genau wie die entsprechenden Labels in Google Fotos Gelegentlich können Artikel falsch gekennzeichnet sein. Deshalb können wir nicht garantieren, die Genauigkeit der Inhaltskategoriefilter.

Kategorien werden eingeschlossen

Wenn Sie mehrere Kategorien einschließen, werden Medienelemente, die mit einer der enthalten sind. Pro Anfrage können maximal 10 Kategorien angegeben werden. Dieser Beispielfilter gibt alle Elemente von LANDSCAPES oder LANDMARKS zurück.

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

Kategorien ausschließen

Es werden nur Medienelemente angezeigt, die mit keiner der ausgeschlossenen Kategorien übereinstimmen. Ähnlich wie bei den eingeschlossenen Kategorien können maximal 10 Kategorien ausgeschlossen werden. pro Anfrage.

Dieser Filter gibt alle Elemente zurück, die nicht PEOPLE oder SELFIES sind:

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

Mehrere Kategorien ein- und ausschließen

Sie können bestimmte Kategorien ein- und andere Kategorien ausschließen. Im folgenden Beispiel gibt LANDSCAPES und LANDMARKS zurück, entfernt jedoch alle Mediaelemente, die PEOPLE oder 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()]
);

Datumsangaben und Zeiträume

Mit Datumsfiltern wird das Datum der zurückgegebenen Ergebnisse auf einen bestimmten Satz von Tage. Es gibt zwei Möglichkeiten, einen Datumsfilter festzulegen: Datumsangaben oder Zeiträume. Datumsangaben und Bereiche zusammen verwendet werden. Medienelemente, die mit einem Datum oder einem Datum übereinstimmen Bereiche zurückgegeben. Optional: Sortierreihenfolge der Ergebnisse geändert werden können.

Daten

Ein Datum besteht aus Jahr, Monat und Tag. Folgende Formate sind zulässig:

  • Jahr
  • Jahr, Monat
  • Jahr, Monat, Tag
  • Tag. Monat
  • Monat

Ist eine Datumskomponente leer oder auf null gesetzt, wird sie verwenden. Wenn Sie beispielsweise den Tag und den Monat, aber nicht das Jahr festlegen, und fordert Artikel von diesem Tag und Monat eines beliebigen Jahres an:

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

Zeiträume

Zeiträume bieten mehr Flexibilität als Datumsangaben. Anstatt beispielsweise mehrere Tage, kann ein Zeitraum verwendet werden, um eine Reihe von Tagen innerhalb eines Monats anzuzeigen.

Ein Zeitraum hat eine startDate und eine endDate, die beide festgelegt werden müssen. Jedes Datum im Bereich hat dieselben Formatbeschränkungen wie in Datumsangaben: Die Datumsangaben müssen dasselbe Format haben: Wenn das Startdatum ein Jahr und Monat muss auch das Enddatum ein Jahr und ein Monat sein. Die Bereiche sind eingeschlossen, sind das Start- und Enddatum im angewendeten Filter enthalten:

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

Daten und Zeiträume kombinieren

Sie können mehrere Datumsangaben und Zeiträume gleichzeitig verwenden. Elemente, die in diesen Zeitraum fallen, werden in den Ergebnissen berücksichtigt. Trennen Sie die Daten und Zeiträume müssen zwar nicht dasselbe Format haben, aber das Start- und Enddatum der für einzelne Bereiche:

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

Medienelementfunktionen

Funktionsfilter beschränken die Ergebnisse auf Elemente mit bestimmten Funktionen, z. B. die in der Google Fotos App als Favoriten markiert sind.

Favoriten

Fügen Sie die FAVORITES Element im FeatureFilter , um nur Medienelemente zurückzugeben, die vom Nutzer als Favoriten markiert wurden:

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

Medientypen

Sie können die Ergebnisse auf den Medientyp beschränken: entweder Foto oder Video.

Foto

Ein PHOTO kann ein beliebiges Bildformat haben:

BMP jpg
GIF PNG
HEIC TIFF
ICO WEBP

Dazu gehören auch spezielle Fototypen wie iOS-Livefotos, Fotos mit Bewegtbild, Panoramen, 360°-Fotos und VR-Fotos.

Video

Ein VIDEO kann verschiedene Videoformate haben:

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

VIDEO umfasst auch spezielle Videoformate wie VR-Videos, Videos in Zeitlupe und Animationen, die mit Google Fotos erstellt wurden, .

Im folgenden Beispiel wird nach PHOTO gefiltert:

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

Mehrere Filter für Medientypen können nicht kombiniert werden.

Nicht in Apps erstellte Daten ausschließen

Um Medienelemente auszuschließen, die nicht von Ihrer App erstellt wurden, können Sie den excludeNonAppCreatedData-Filter, wie im folgenden Beispiel gezeigt:

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

Wenn Sie die Methode .readonly.appcreateddata wird dieser Filter ignoriert.

Archivierter Status

Möglicherweise haben Ihre Nutzer einige ihrer Fotos archiviert. Standardmäßig werden archivierte Fotos nicht in Suchanfragen zurückgegeben. Um archivierte Elemente einzubeziehen, können Sie in aus, wie im folgenden Beispiel gezeigt:

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

Filter kombinieren

Verschiedene Arten von Filtern können kombiniert werden. Nur Elemente, die mit allen die angeforderten Features zurückgegeben werden.

Beim Kombinieren von Filtern sind die Formatierungsbeschränkungen für jeden Filtertyp die wie bei ihrer Einzelnutzung. Im folgenden Beispiel werden nur Fotos die als SPORT kategorisiert wurden und entweder aus 2014 oder 2010 stammen, sind zurückgegeben:

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

Ergebnisse sortieren

Nur Abfragen mit Datumsfiltern können sortiert werden.

Wenn Sie keine Sortieroption angeben, werden Ihre Ergebnisse in absteigender Reihenfolge (neueste zuerst).

Die folgende Tabelle zeigt die unterstützten Optionen für den Parameter orderBy:

orderBy-Parameter
MediaMetadata.creation_time desc Gibt Medienelemente in absteigender Reihenfolge zurück (neueste Elemente zuerst)
MediaMetadata.creation_time Gibt Medienelemente in aufsteigender Reihenfolge zurück (älteste Elemente zuerst)

Im folgenden Beispiel werden alle Medienelemente aus dem Jahr 2017 zurückgegeben, wobei die ältesten die erste und die neueste letzte.

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