Wyszukiwanie i stosowanie filtrów

Wymagane zakresy autoryzacji

Interfejs Google Photos Library API obejmuje wiele zakresów używanych do uzyskiwania dostępu do elementów multimedialnych i albumów. Elementy multimedialne zwracane w ramach różnych wywołań różnią się w zależności od zakresów zażądanych przez programistę.

Zakres photoslibrary.readonly umożliwia dostęp do wszystkich elementów multimedialnych w bibliotece użytkownika. Zakres photoslibrary.readonly.appcreateddata umożliwia dostęp tylko do elementów multimedialnych utworzonych przez aplikację. Więcej informacji znajdziesz w artykule o zakresach autoryzacji.

Dostępne filtry

W bibliotece użytkownika możesz wyszukiwać konkretne rodzaje multimediów. Możesz na przykład wybrać tylko produkty przedstawiające zwierzęta z określonego dnia lub wykluczyć zdjęcia rachunków. Możesz wykluczać lub uwzględniać konkretne elementy, stosując filtry do albumu lub listy biblioteki. Dostępnych jest 5 filtrów zależnych od właściwości elementu multimedialnego:

W żądaniu mediaItems:search nie należy używać filtrów, jeśli ustawiono albumId. Jeśli podczas ustawiania identyfikatora albumu używany jest filtr, zwracany jest błąd INVALID_ARGUMENT (400).

Wyniki są sortowane według czasu utworzenia elementu multimedialnego. Kolejność sortowania można zmieniać dla zapytań, które korzystają z filtrów daty.

Poczekaj, aż nowo przesłane multimedia pojawią się w wynikach wyszukiwania. Multimedia natychmiast pojawiają się w niefiltrowanych wynikach wyszukiwania.

Elementy multimedialne z datą w przyszłości nie pojawiają się w filtrowanych wynikach wyszukiwania. Pojawiają się one w niefiltrowanych wynikach wyszukiwania i wyszukiwania albumów.

Stosowanie filtra

Aby zastosować filtr, wywołaj metodę mediaItems.search i określ 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 następującą 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 Wyświetlanie listy zawartości, albumów i elementów multimedialnych z biblioteki.

Kategorii treści

Wszystkie elementy multimedialne są przetwarzane i przypisywane do nich etykiety. Możesz uwzględnić lub wykluczyć dowolne 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ą szeroki zakres nośników. Ta kategoria zwykle obejmuje przedmioty uzyskane przez użytkownika w celu wykonania jakiegoś zadania i mało prawdopodobne, że będzie on potrzebny po jego zakończeniu. Mogą to być dokumenty, rachunki, zrzuty ekranu, notatki, menu i inne podobne elementy multimedialne.

Kategorie są tak dokładne, jak odpowiadające im etykiety w Zdjęciach Google. Czasami elementy mogą być nieprawidłowo oznaczone, dlatego nie możemy zagwarantować poprawności filtrów kategorii treści.

Uwzględnia kategorie

Jeśli uwzględnisz kilka kategorii, uwzględnione zostaną elementy multimedialne pasujące do dowolnej z nich. Żądanie może obejmować maksymalnie 10 kategorii. Ten przykładowy filtr zwraca wszystkie elementy 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 elementy multimedialne, które nie pasują do żadnej z wykluczonych kategorii. Podobnie jak w przypadku uwzględnionych kategorii, w jednym żądaniu możesz wykluczyć maksymalnie 10 kategorii.

Ten filtr zwraca wszystkie elementy, które nie są wartościami 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ędnić niektóre kategorie i wykluczyć inne. Ten przykład zwraca wartości 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 zbioru dni. Filtr dat można określić na 2 sposoby: daty lub zakresy. Daty i zakresy mogą być używane razem. Zwrócone zostaną elementy multimedialne, które pasują do dowolnego z terminów lub zakresów 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 składnik daty jest pusty lub ma wartość 0, jest traktowany jako symbol wieloznaczny. Jeśli np. masz ustawiony dzień i miesiąc, ale nie rok, to żądanie obejmuje elementy z tego dnia i miesiąca dowolnego 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ż daty. Na przykład zamiast dodawać wiele dat, możesz użyć zakresu dat do wyświetlenia zbioru dni w miesiącu.

Zakres dat zawiera elementy startDate i endDate. Oba muszą być ustawione. Każda data w zakresie podlega takim samym ograniczeniom formatu jak opisano w sekcji Daty. Daty muszą mieć ten sam format: jeśli data rozpoczęcia to rok i miesiąc, data zakończenia musi też obejmować rok i miesiąc. Zakresy są stosowane włącznie, a daty rozpoczęcia i zakończenia są uwzględniane w zastosowanym filtrze:

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żyć wielu dat i wielu zakresów dat naraz. W wynikach uwzględniane są elementy, które mieszczą się w dowolnej z tych dat. Osobne daty i zakresy dat nie muszą mieć tego samego formatu. Pamiętaj jednak, że mogą to być daty rozpoczęcia i zakończenia:

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 cech ograniczają wyniki do elementów o określonych funkcjach, na przykład oznaczonych jako ulubione w aplikacji Zdjęcia Google.

Ulubione

Dodaj w elemencie FeatureFilter funkcję elementu FAVORITES, aby zwracać tylko elementy multimedialne, które zostały oznaczone jako ulubione przez użytkownika:

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 filmu.

Zdjęcie

Identyfikator PHOTO może mieć dowolny z kilku formatów obrazu:

BMP JPG
GIF PNG
HEIC TIFF
ICO WebP

Znajdują się w niej również specjalne typy zdjęć, np. zdjęcia na żywo z iOS, zdjęcia ruchome, panoramy, zdjęcia sferyczne i zdjęcia VR.

Wideo

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

protokół 3GP MMV
3G2 MOD
ASF MOV
AVI MP4
DIVX MPG
M2T MTS
M2T WYK
M4V WMV
MKV  

VIDEO obejmuje też specjalne formaty filmów, np. filmy VR, zwolnione tempo i animacje utworzone w aplikacji Zdjęcia Google.

Oto przykładowe filtry utworzone według atrybutu 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ć filtrów różnych typów multimediów.

Wyklucz dane nieutworzone przez aplikacje

Aby wykluczyć elementy multimedialne, które nie zostały utworzone przez Twoją aplikację, możesz ustawić filtr excludeNonAppCreatedData w ten sposób:

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

Pamiętaj, że jeśli używasz zakresu .readonly.appcreateddata, ten filtr jest ignorowany.

Stan zarchiwizowany

Użytkownicy mogli archiwizować niektóre zdjęcia. Domyślnie zarchiwizowane zdjęcia nie są zwracane w wynikach wyszukiwania. Aby uwzględniać zarchiwizowane elementy, możesz ustawić w filtrze flagę, 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 elementy, które pasują do wszystkich żądanych cech.

W przypadku łączenia filtrów ograniczenia formatowania poszczególnych typów filtrów są takie same jak w przypadku używania ich pojedynczo. W tym przykładzie zwracane są tylko te zdjęcia, które zostały skategoryzowane jako SPORT i powstały 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

Można sortować tylko zapytania korzystające z filtrów daty.

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

Ta tabela zawiera obsługiwane opcje parametru orderBy:

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

Poniższy przykład pokazuje wszystkie elementy multimedialne z 2017 roku, w tym najstarsze i najnowsze ostatnie.

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