Android App

[AEM as a Cloud Service]{class="badge informative"}

Exempelprogram är ett bra sätt att utforska Adobe Experience Manager headless-funktioner (AEM). I det här Android-programmet visas hur du frågar efter innehåll med hjälp av GraphQL API:er för AEM. AEM Headless Client för Java används för att köra GraphQL-frågor och mappa data till Java-objekt för att styra programmet.

Android Java-appen med AEM Headless

Visa källkoden på GitHub

Förutsättningar prerequisites

Följande verktyg bör installeras lokalt:

AEM

Android fungerar med följande AEM driftsättningsalternativ. Alla distributioner kräver att WKND-platsen v3.0.0+ är installerad.

Android-programmet är utformat för att ansluta till en AEM Publish -miljö, men det kan hämta innehåll från AEM författare om autentisering anges i Android-programmets konfiguration.

Så här använder du

  1. Klona adobe/aem-guides-wknd-graphql-databasen:

    code language-shell
    $ git clone git@github.com:adobe/aem-guides-wknd-graphql.git
    
  2. Öppna Android Studio och öppna mappen android-app

  3. Ändra filen config.properties vid app/src/main/assets/config.properties och uppdatera contentApi.endpoint så att den matchar AEM:

    code language-plain
    contentApi.endpoint=https://publish-p123-e456.adobeaemcloud.com
    

    Grundläggande autentisering

    contentApi.user och contentApi.password autentiserar en lokal AEM med åtkomst till WKND GraphQL-innehåll.

    code language-plain
    contentApi.endpoint=https://author-p123-e456.adobeaemcloud.com
    contentApi.user=my-special-android-app-user
    contentApi.password=password123
    
  4. Hämta en virtuell Android-enhet (minst API 28).

  5. Bygg och distribuera appen med Android-emulatorn.

Ansluta till AEM

Om du ansluter till en AEM författarmiljö krävs behörighet. AEMHeadlessClientBuilder ger möjlighet att använda tokenbaserad autentisering. Så här använder du tokenbaserad klientbyggare för uppdatering av autentisering i AdventureLoader.java och AdventuresLoader.java:

/* Comment out basicAuth
 if (user != null && password != null) {
   builder.basicAuth(user, password);
 }
*/

// use token-authentication where `token` is a String representing the token
builder.tokenAuth(token)

Koden

Nedan följer en kort sammanfattning av de filer och den kod som är viktiga för programmet. Den fullständiga koden finns på GitHub.

Beständiga frågor

Efter AEM Headless-metodtips använder iOS-programmet AEM GraphQL beständiga frågor för att fråga efter äventyrsdata. Programmet använder två beständiga frågor:

  • wknd/adventures-all beständig fråga, som returnerar alla äventyr i AEM med en förkortad uppsättning egenskaper. Den här beständiga frågan styr den inledande vyns äventyrslista.
# Retrieves a list of all adventures
{
    adventureList {
        items {
            _path
            slug
            title
            price
            tripLength
            primaryImage {
                ... on ImageRef {
                _dynamicUrl
                _path
                }
            }
        }
    }
}
  • wknd/adventure-by-slug beständig fråga, som returnerar ett enskilt äventyr från slug (en anpassad egenskap som unikt identifierar ett äventyr) med en fullständig uppsättning egenskaper. Den här beständiga frågan styr äventyrsdetaljvyerna.
# Retrieves an adventure Content Fragment based on it's slug
# Example query variables:
# {"slug": "bali-surf-camp"}
# Technically returns an adventure list but since the the slug
# property is set to be unique in the CF Model, only a single CF is expected

query($slug: String!) {
  adventureList(filter: {
        slug: {
          _expressions: [ { value: $slug } ]
        }
      }) {
    items {
      _path
      title
      slug
      activity
      adventureType
      price
      tripLength
      groupSize
      difficulty
      price
      primaryImage {
        ... on ImageRef {
          _dynamicUrl
          _path
        }
      }
      description {
        json
        plaintext
      }
      itinerary {
        json
        plaintext
      }
    }
    _references {
      ...on AdventureModel {
        _path
        slug
        title
        price
        __typename
      }
    }
  }
}

Kör GraphQL beständig fråga

AEM beständiga frågor körs via HTTP-GET och därför används klienten AEM Headless för Java för att köra beständiga GraphQL-frågor mot AEM och läsa in äventyret i appen.

Varje beständig fråga har en motsvarande inläsarklass, som asynkront anropar den AEM HTTP-GETENS slutpunkt och returnerar äventyrsdata med den anpassade definierade datamodellen.

  • loader/AdventuresLoader.java

    Hämtar listan med tillägg på programmets startskärm med hjälp av den wknd-shared/adventures-all beständiga frågan.

  • loader/AdventureLoader.java

    Hämtar ett enskilt äventyr som markerar det via parametern slug, med hjälp av den wknd-shared/adventure-by-slug beständiga frågan.

//AdventuresLoader.java

public static final String PERSISTED_QUERY_NAME = "/wknd-shared/adventures-all";
...
AEMHeadlessClientBuilder builder = AEMHeadlessClient.builder().endpoint(config.getContentApiEndpoint());

// Optional authentication for basic auth
String user = config.getContentApiUser();
String password = config.getContentApiPassword();

if (user != null && password != null) {
    builder.basicAuth(user, password);
}

AEMHeadlessClient client = builder.build();
// run a persistent query and get a response
GraphQlResponse response = client.runPersistedQuery(PERSISTED_QUERY_NAME);

GraphQL svarsdatamodeller data-models

Adventure.java är en Java POJO som initieras med JSON-data från GraphQL-begäran och modellerar ett äventyr som ska användas i Android-programmets vyer.

Vyer

Android-programmet använder två vyer för att presentera äventyrsdata i mobilupplevelsen.

  • AdventureListFragment.java

    Anropar AdventuresLoader och visar de returnerade äventyren i en lista.

  • AdventureDetailFragment.java

    Anropar AdventureLoader med den slug-parameter som skickas via äventyvalet i vyn AdventureListFragment och visar information om ett enskilt äventyr.

Fjärrbilder

loader/RemoteImagesCache.java är en verktygsklass som hjälper till att förbereda fjärrbilder i ett cacheminne så att de kan användas med Android UI-element. Innehållet i äventyret refererar till bilder i AEM Assets via en URL och den här klassen används för att visa innehållet.

Ytterligare resurser

recommendation-more-help
e25b6834-e87f-4ff3-ba56-4cd16cdfdec4