Wyszukiwanie i stosowanie filtrów

Wymagane zakresy autoryzacji

Zakres photoslibrary.readonly umożliwia dostęp do wszystkich elementów multimedialnych w bibliotece użytkownika.

Wyszukiwanie i stosowanie filtrów do treści tworzonych przez aplikacje wymaga zakresu photoslibrary.readonly.appcreateddata. Więcej informacji o zakresach znajdziesz w artykule o zakresach autoryzacji.

Dostępne filtry

W bibliotece elementów multimedialnych utworzonych przez użytkownika możesz wyszukiwać określone rodzaje multimediów. Możesz na przykład wybrać tylko zdjęcia zwierząt lub zdjęcia z określonego dnia. Możesz też wykluczyć zdjęcia paragonów. Możesz wykluczać lub uwzględniać określone elementy, stosując filtry w albumie lub bibliotece. Dostępnych jest 5 filtrów na podstawie właściwości elementów multimedialnych:

Filtrów nie należy używać w żądaniu mediaItems.search, jeśli parametr albumId jest ustawiony. Jeśli filtr jest używany, gdy ustawiono albumId, zwracany jest błąd INVALID_ARGUMENT (400).

Wyniki są sortowane według czasu utworzenia elementu multimedialnego. W przypadku zapytań z filtrami dat można zmienić kolejność sortowania.

Poczekaj, aż nowo przesłane multimedia pojawią się w wynikach wyszukiwania. Treści multimedialne będą natychmiast widoczne w niefiltrowanych wyszukiwaniach.

Elementy multimedialne z datą w przyszłości nie pojawiają się w wyszukiwaniach z filtrami. Wyświetlają się w niefiltrowanych wynikach wyszukiwania i w wynikach wyszukiwania albumów.

Stosowanie filtra

Aby zastosować filtr, wywołaj funkcję mediaItems.search i wskaż właściwość filter.

REST

Oto żądanie POST:

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

Żądanie POST zwraca tę odpowiedź:

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

Szczegółowe informacje znajdziesz w artykule Lista treści biblioteki, albumów i elementów multimedialnych.

Kategorie treści

Wszystkie elementy multimedialne są przetwarzane i oznaczone etykietami. Możesz uwzględniać i wykluczać dowolną z tych kategorii.

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  

Zdjęcia użytkowe obejmują szeroką gamę nośników. Ta kategoria obejmuje zazwyczaj elementy, które użytkownik sfotografował w celu wykonania określonego zadania, i które prawdopodobnie nie będą mu już potrzebne po jego zakończeniu. Zawiera dokumenty, rachunki, zrzuty ekranu, przyklejone notatki, menu i inne podobne elementy multimedialne.

Dokładność kategorii zależy od dokładności odpowiednich etykiet w Zdjęciach Google. Czasami produkty mogą być źle opisane, dlatego nie możemy zagwarantować dokładności filtrów kategorii treści.

Uwzględnianie kategorii

Jeśli dodasz wiele kategorii, uwzględnione zostaną elementy multimedialne pasujące do dowolnej z tych kategorii. W każdym żądaniu można uwzględnić maksymalnie 10 kategorii. Ten przykładowy filtr zwraca wszystkie elementy o wartości LANDSCAPES lub 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()]
);

Wykluczanie kategorii

Wyświetlane są tylko te treści multimedialne, które nie pasują do żadnej z wykluczonych kategorii. Podobnie jak w przypadku uwzględnionych kategorii, w każdym żądaniu można wykluczyć maksymalnie 10 kategorii.

Ten filtr zwraca wszystkie elementy, które nie są PEOPLE ani 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()]
);

Uwzględnianie i wykluczanie wielu kategorii

Możesz uwzględniać niektóre kategorie i wykluczać inne. Ten przykład zwraca LANDSCAPES i LANDMARKS, ale usuwa wszystkie elementy multimedialne, które zawierają PEOPLE lub 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()]
);

Daty i zakresy dat

Filtry dat ograniczają datę zwracanych wyników do określonego zestawu dni. Filtr dat można określić na 2 sposoby: wybierając daty lub zakresy. Daty i zakresy dat można stosować razem. Zwracane są elementy multimediów pasujące do dowolnej daty lub zakresu dat. Opcjonalnie można zmienić kolejność sortowania wyników.

Daty

Data zawiera rok, miesiąc i dzień. Akceptowane są te formaty:

  • Rok
  • Rok, miesiąc
  • Rok, miesiąc, dzień
  • Miesiąc, dzień
  • Miesiąc

Jeśli element daty jest pusty lub ustawiony na 0, jest traktowany jako symbol wieloznaczny. Jeśli na przykład ustawisz dzień i miesiąc, ale nie rok, żądasz elementów z tego dnia i miesiąca w dowolnym roku:

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

Zakresy dat

Zakresy dat zapewniają większą elastyczność niż same daty. Na przykład zamiast dodawać wiele dat, możesz użyć zakresu dat, aby wyświetlić zestaw dni w miesiącu.

Zakres dat obejmuje właściwości startDate i endDate – oba te elementy muszą być skonfigurowane. Każda data w zakresie ma te same ograniczenia formatu, o których mowa w sekcji Daty. Daty muszą mieć ten sam format: jeśli data rozpoczęcia zawiera rok i miesiąc, data zakończenia musi też zawierać rok i miesiąc. Zakresy są stosowane łącznie, a w zastosowanej konfiguracji uwzględniane są daty rozpoczęcia i zakończenia:

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

Łączenie dat i zakresów dat

Możesz używać wielu dat i zakresów dat jednocześnie. W wynikach wyświetlane są elementy, które mieszczą się w jednym z tych dat. Poszczególne daty i zakresy dat nie muszą być podane w tym samym formacie, ale daty rozpoczęcia i zakończenia poszczególnych zakresów muszą być podane w tym samym formacie:

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

Funkcje elementu multimedialnego

Filtry funkcji ograniczają wyniki do elementów, które mają określone funkcje, na przykład zostały oznaczone jako ulubione w aplikacji Zdjęcia Google.

Ulubione

Użyj parametru FAVORITES w funkcji FeatureFilter, aby zwrócić tylko te elementy multimedialne, które użytkownik oznaczył jako ulubione:

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

Typy multimediów

Możesz ograniczyć wyniki do typu multimediów: zdjęcia lub filmów.

Zdjęcie

PHOTO może być w dowolnym formacie obrazu:

BMP JPG
GIF PNG
HEIC TIFF
ICO WebP

Obejmuje ona też specjalne typy zdjęć, takie jak zdjęcia na żywo w iOS, zdjęcia ruchome, panoramy, zdjęcia sferyczne i zdjęcia VR.

Wideo

VIDEO może mieć różne formaty wideo:

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

VIDEO obejmuje też specjalne formaty filmów, takie jak filmy VR, filmy w zwolnionym tempie i animacje utworzone w aplikacji Zdjęcia Google.

W tym przykładzie filtry według tego pola: 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()]
);

Nie można łączyć wielu typów multimediów.

Stan zarchiwizowany

Użytkownicy mogli zarchiwizować niektóre zdjęcia. Domyślnie zarchiwizowane zdjęcia nie są uwzględniane w wynikach wyszukiwania. Aby uwzględnić zarchiwizowane elementy, możesz ustawić flagę w filtrze, jak w tym przykładzie:

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

Łączenie filtrów

Można łączyć różne rodzaje filtrów. Zwracane są tylko te elementy, które pasują do wszystkich żądanych funkcji.

W przypadku łączenia filtrów ograniczenia formatowania każdego typu filtra są takie same jak w przypadku ich używania pojedynczo. W tym przykładzie zwracane są tylko zdjęcia zakwalifikowane jako SPORT i zrobione w 2014 lub 2010 roku:

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

Sortowanie wyników

Sortowanie jest możliwe tylko w przypadku zapytań z filtrami daty.

Jeśli nie określisz opcji sortowania, wyniki zostaną posortowane w kolejności malejącej (najpierw najnowsze).

Ta tabela zawiera obsługiwane opcje parametru orderBy:

Parametr orderBy
MediaMetadata.creation_time desc Zwraca elementy multimedialne w kolejności malejącej (najpierw najnowsze elementy)
MediaMetadata.creation_time Zwraca elementy multimedialne w kolejności rosnącej (od najstarszych)

W tym przykładzie zwracane są wszystkie elementy multimedialne z 2017 roku, przy czym najstarsze są wyświetlane na początku, a najnowsze na końcu.

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