Empfehlungen in Android N und früheren Versionen

Bei der Interaktion mit Fernsehern bevorzugen Nutzer im Allgemeinen, vor der Wiedergabe nur wenig Input zu geben Inhalte. Ein ideales Szenario für viele TV-Nutzer ist: hinsetzen, einschalten und zusehen. Ganz einfach um Nutzer zu Inhalten zu leiten, die ihnen gefallen, ist in der Regel der Weg, den sie bevorzugen.

Hinweis:Verwenden Sie die hier beschriebenen APIs, um Empfehlungen zu geben. Nur in Apps mit Android-Versionen bis einschließlich Android 7.1 (API-Level 25) verfügbar. Liefern Empfehlungen für Apps mit Android 8.0 (API-Level 26) und höher, muss Ihre App die Empfehlungskanäle.

Das Android-Framework unterstützt die Interaktion mit der Mindestanzahl an Input, indem es eine Zeile mit Empfehlungen bereitstellt. auf dem Startbildschirm angezeigt. Inhaltsempfehlungen werden in der ersten Zeile des TV-Startbildschirms nach dem der ersten Nutzung des Geräts. Hilfreiche Empfehlungen aus dem Inhaltskatalog deiner App damit Nutzer zu Ihrer App zurückkehren.

Abbildung 1: Ein Beispiel für die Zeile „Empfehlung“.

In diesem Leitfaden erfährst du, wie du Empfehlungen erstellst und für das Android-Framework bereitstellst. damit Nutzer deine App-Inhalte leicht finden und genießen können. Siehe auch die Beispielimplementierung in die <ph type="x-smartling-placeholder"></ph> Leanback-Beispiel-App .

Best Practices für Empfehlungen

Mithilfe von Empfehlungen finden Nutzer schnell die Inhalte und Apps, die ihnen gefallen. Wird erstellt... qualitativ hochwertige und für Nutzende relevante Empfehlungen sind ein wichtiger Faktor bei der Erstellung die Nutzerfreundlichkeit Ihrer TV-App zu verbessern. Daher sollten Sie sich genau überlegen, Empfehlungen, die Sie dem Nutzer präsentieren, und verwalten sie sorgfältig.

Arten von Empfehlungen

Wenn du Empfehlungen erstellst, solltest du Nutzer zu unvollständigen Wiedergabeaktivitäten oder Aktivitäten vorschlagen, die dies auf ähnliche Inhalte ausdehnen. Hier sind eine bestimmte Art von Empfehlungen, die Sie berücksichtigen sollten:

  • Empfehlungen für Fortsetzungsinhalte für die nächste Folge, die Nutzer fortsetzen können eine Serie ansehen. Oder folge Empfehlungen für das Fortsetzen von pausierten Filmen, Serien oder Podcasts So können Nutzer mit nur wenigen Klicks pausierte Inhalte wieder aufrufen.
  • Empfehlungen für neue Inhalte, z. B. für eine neue Folge, wenn der Nutzer eine andere Serie angesehen haben. Wenn Nutzer in Ihrer App Abos, Folgen oder neue Inhaltsempfehlungen für nicht angesehene Inhalte in der Liste der beobachteten Inhalte verwenden.
  • Empfehlungen für ähnliche Inhalte, die auf den Nutzeranforderungen basieren des bisherigen Wiedergabeverhaltens.

Weitere Informationen zum Erstellen von Empfehlungskarten für eine optimale Nutzererfahrung finden Sie unter Empfehlungszeile in den Android TV-Designspezifikationen.

Empfehlungen aktualisieren

Wenn Sie Empfehlungen aktualisieren, sollten Sie sie nicht einfach entfernen und neu posten. werden die Empfehlungen am Ende der Zeile mit Empfehlungen angezeigt. Sobald ein Inhaltselement, z. B. Film, wurde abgespielt, aus den Empfehlungen entfernen.

Empfehlungen anpassen

Sie können Empfehlungskarten anpassen, um Brandinginformationen zu vermitteln, indem Sie die Benutzeroberfläche festlegen Elemente wie Vorder- und Hintergrundbild, Farbe, App-Symbol, Titel und Untertitel der Karte Weitere Informationen finden Sie unter Empfehlungszeile in den Android TV-Designspezifikationen.

Empfehlungen für Gruppen

Optional können Sie Empfehlungen basierend auf der Empfehlungsquelle gruppieren. Beispiel: Ihre App kann zwei Gruppen von Empfehlungen angezeigt werden: Empfehlungen für Inhalte, die der Nutzer abonniert hat, und Empfehlungen für neue angesagte Inhalte, die dem Nutzer vielleicht noch nicht bekannt sind.

Beim Erstellen oder Aktualisieren von Empfehlungen werden Empfehlungen für jede Gruppe separat geordnet und in eine bestimmte Reihenfolge gebracht. in der Empfehlungszeile. Durch die Bereitstellung von Gruppeninformationen für Ihre Empfehlungen können Sie sicherstellen, Empfehlungen werden nicht unter den Empfehlungen angeordnet, die nicht mit dem Thema zusammenhängen.

Verwenden Sie Mit NotificationCompat.Builder.setGroup() legen Sie den Gruppenschlüsselstring einer Empfehlung fest. Für um eine Empfehlung als zu einer Gruppe gehörig zu markieren, die neue angesagte Inhalte enthält, können Sie setGroup("trending") anrufen.

Empfehlungsdienst erstellen

Inhaltsempfehlungen werden im Hintergrund verarbeitet. Damit Ihre Anwendung zu Empfehlungen beitragen, erstellen Sie einen Dienst, der regelmäßig Einträge aus Ihrem App-Katalog mit der Liste der Empfehlungen des Systems.

Das folgende Codebeispiel zeigt, wie IntentService auf Erstellen Sie einen Empfehlungsdienst für Ihre Anwendung:

Kotlin

class UpdateRecommendationsService : IntentService("RecommendationService") {
    override protected fun onHandleIntent(intent: Intent) {
        Log.d(TAG, "Updating recommendation cards")
        val recommendations = VideoProvider.getMovieList()
        if (recommendations == null) return

        var count = 0

        try {
            val builder = RecommendationBuilder()
                    .setContext(applicationContext)
                    .setSmallIcon(R.drawable.videos_by_google_icon)

            for (entry in recommendations.entrySet()) {
                for (movie in entry.getValue()) {
                    Log.d(TAG, "Recommendation - " + movie.getTitle())

                    builder.setBackground(movie.getCardImageUrl())
                            .setId(count + 1)
                            .setPriority(MAX_RECOMMENDATIONS - count)
                            .setTitle(movie.getTitle())
                            .setDescription(getString(R.string.popular_header))
                            .setImage(movie.getCardImageUrl())
                            .setIntent(buildPendingIntent(movie))
                            .build()
                    if (++count >= MAX_RECOMMENDATIONS) {
                        break
                    }
                }
                if (++count >= MAX_RECOMMENDATIONS) {
                    break
                }
            }
        } catch (e: IOException) {
            Log.e(TAG, "Unable to update recommendation", e)
        }
    }

    private fun buildPendingIntent(movie: Movie): PendingIntent {
        val detailsIntent = Intent(this, DetailsActivity::class.java)
        detailsIntent.putExtra("Movie", movie)

        val stackBuilder = TaskStackBuilder.create(this)
        stackBuilder.addParentStack(DetailsActivity::class.java)
        stackBuilder.addNextIntent(detailsIntent)

        // Ensure a unique PendingIntents, otherwise all
        // recommendations end up with the same PendingIntent
        detailsIntent.setAction(movie.getId().toString())

        val intent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT)
        return intent
    }

    companion object {
        private val TAG = "UpdateRecommendationsService"
        private val MAX_RECOMMENDATIONS = 3
    }
}

Java

public class UpdateRecommendationsService extends IntentService {
    private static final String TAG = "UpdateRecommendationsService";
    private static final int MAX_RECOMMENDATIONS = 3;

    public UpdateRecommendationsService() {
        super("RecommendationService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d(TAG, "Updating recommendation cards");
        HashMap<String, List<Movie>> recommendations = VideoProvider.getMovieList();
        if (recommendations == null) return;

        int count = 0;

        try {
            RecommendationBuilder builder = new RecommendationBuilder()
                    .setContext(getApplicationContext())
                    .setSmallIcon(R.drawable.videos_by_google_icon);

            for (Map.Entry<String, List<Movie>> entry : recommendations.entrySet()) {
                for (Movie movie : entry.getValue()) {
                    Log.d(TAG, "Recommendation - " + movie.getTitle());

                    builder.setBackground(movie.getCardImageUrl())
                            .setId(count + 1)
                            .setPriority(MAX_RECOMMENDATIONS - count)
                            .setTitle(movie.getTitle())
                            .setDescription(getString(R.string.popular_header))
                            .setImage(movie.getCardImageUrl())
                            .setIntent(buildPendingIntent(movie))
                            .build();

                    if (++count >= MAX_RECOMMENDATIONS) {
                        break;
                    }
                }
                if (++count >= MAX_RECOMMENDATIONS) {
                    break;
                }
            }
        } catch (IOException e) {
            Log.e(TAG, "Unable to update recommendation", e);
        }
    }

    private PendingIntent buildPendingIntent(Movie movie) {
        Intent detailsIntent = new Intent(this, DetailsActivity.class);
        detailsIntent.putExtra("Movie", movie);

        TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
        stackBuilder.addParentStack(DetailsActivity.class);
        stackBuilder.addNextIntent(detailsIntent);
        // Ensure a unique PendingIntents, otherwise all
        // recommendations end up with the same PendingIntent
        detailsIntent.setAction(Long.toString(movie.getId()));

        PendingIntent intent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
        return intent;
    }
}

Registrieren Sie ihn mithilfe Ihres App-Manifests. Das folgende Code-Snippet zeigt, wie diese Klasse als Dienst deklariert wird: 

<manifest ... >
  <application ... >
    ...

    <service
            android:name="com.example.android.tvleanback.UpdateRecommendationsService"
            android:enabled="true" />
  </application>
</manifest>

Empfehlungen erstellen

Sobald Ihr Empfehlungsdienst ausgeführt wird, muss er Empfehlungen erstellen und an Android-Framework entwickelt. Das Framework empfängt die Empfehlungen als Notification-Objekte, die eine bestimmte Vorlage verwenden und mit einer bestimmten Kategorie.

Werte festlegen

Um die Werte der UI-Elemente für die Empfehlungskarte festzulegen, erstellen Sie eine Builder-Klasse, das wie folgt beschriebene Builder-Muster. Zuerst legen Sie die Werte der Empfehlungskarte fest Elemente.

Kotlin

class RecommendationBuilder {
    ...

    fun setTitle(title: String): RecommendationBuilder {
        this.title = title
        return this
    }

    fun setDescription(description: String): RecommendationBuilder {
        this.description = description
        return this
    }

    fun setImage(uri: String): RecommendationBuilder {
        imageUri = uri
        return this
    }

    fun setBackground(uri: String): RecommendationBuilder {
        backgroundUri = uri
        return this
    }

...

Java

public class RecommendationBuilder {
    ...

    public RecommendationBuilder setTitle(String title) {
            this.title = title;
            return this;
        }

        public RecommendationBuilder setDescription(String description) {
            this.description = description;
            return this;
        }

        public RecommendationBuilder setImage(String uri) {
            imageUri = uri;
            return this;
        }

        public RecommendationBuilder setBackground(String uri) {
            backgroundUri = uri;
            return this;
        }
...

Benachrichtigung erstellen

Nachdem Sie die Werte festgelegt haben, erstellen Sie die Benachrichtigung und weisen die Werte aus dem Builder zu. der Benachrichtigung hinzu und rufen NotificationCompat.Builder.build() auf.

Rufen Sie außerdem setLocalOnly() damit die NotificationCompat.BigPictureStyle-Benachrichtigung auf anderen Geräten.

Das folgende Codebeispiel zeigt, wie eine Empfehlung erstellt wird.

Kotlin

class RecommendationBuilder {
    ...

    @Throws(IOException::class)
    fun build(): Notification {
        ...

        val notification = NotificationCompat.BigPictureStyle(
        NotificationCompat.Builder(context)
                .setContentTitle(title)
                .setContentText(description)
                .setPriority(priority)
                .setLocalOnly(true)
                .setOngoing(true)
                .setColor(context.resources.getColor(R.color.fastlane_background))
                .setCategory(Notification.CATEGORY_RECOMMENDATION)
                .setLargeIcon(image)
                .setSmallIcon(smallIcon)
                .setContentIntent(intent)
                .setExtras(extras))
                .build()

        return notification
    }
}

Java

public class RecommendationBuilder {
    ...

    public Notification build() throws IOException {
        ...

        Notification notification = new NotificationCompat.BigPictureStyle(
                new NotificationCompat.Builder(context)
                        .setContentTitle(title)
                        .setContentText(description)
                        .setPriority(priority)
                        .setLocalOnly(true)
                        .setOngoing(true)
                        .setColor(context.getResources().getColor(R.color.fastlane_background))
                        .setCategory(Notification.CATEGORY_RECOMMENDATION)
                        .setLargeIcon(image)
                        .setSmallIcon(smallIcon)
                        .setContentIntent(intent)
                        .setExtras(extras))
                .build();

        return notification;
    }
}

Empfehlungsdienst ausführen

Der Empfehlungsdienst Ihrer App muss regelmäßig ausgeführt werden, um aktuelle Empfehlungen. Erstellen Sie zum Ausführen Ihres Dienstes eine Klasse, die einen Timer ausführt und in regelmäßigen Abständen. Im folgenden Codebeispiel wird die Klasse BroadcastReceiver erweitert, um die regelmäßige Ausführung eines Empfehlungsdienstes zu starten jede halbe Stunde:

Kotlin

class BootupActivity : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        Log.d(TAG, "BootupActivity initiated")
        if (intent.action.endsWith(Intent.ACTION_BOOT_COMPLETED)) {
            scheduleRecommendationUpdate(context)
        }
    }

    private fun scheduleRecommendationUpdate(context: Context) {
        Log.d(TAG, "Scheduling recommendations update")
        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
        val recommendationIntent = Intent(context, UpdateRecommendationsService::class.java)
        val alarmIntent = PendingIntent.getService(context, 0, recommendationIntent, 0)
        alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                INITIAL_DELAY,
                AlarmManager.INTERVAL_HALF_HOUR,
                alarmIntent
        )
    }

    companion object {
        private val TAG = "BootupActivity"
        private val INITIAL_DELAY:Long = 5000
    }
}

Java

public class BootupActivity extends BroadcastReceiver {
    private static final String TAG = "BootupActivity";

    private static final long INITIAL_DELAY = 5000;

    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d(TAG, "BootupActivity initiated");
        if (intent.getAction().endsWith(Intent.ACTION_BOOT_COMPLETED)) {
            scheduleRecommendationUpdate(context);
        }
    }

    private void scheduleRecommendationUpdate(Context context) {
        Log.d(TAG, "Scheduling recommendations update");

        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        Intent recommendationIntent = new Intent(context, UpdateRecommendationsService.class);
        PendingIntent alarmIntent = PendingIntent.getService(context, 0, recommendationIntent, 0);

        alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                INITIAL_DELAY,
                AlarmManager.INTERVAL_HALF_HOUR,
                alarmIntent);
    }
}

Diese Implementierung der BroadcastReceiver-Klasse muss nach dem Start ausgeführt werden des Fernsehers, auf dem es installiert ist. Registriere diesen Kurs in deiner App, um dies zu tun Manifest mit einem Intent-Filter, der den Abschluss des Gerätestartvorgangs überwacht. Die Der folgende Beispielcode zeigt, wie diese Konfiguration zum Manifest hinzugefügt wird: 

<manifest ... >
  <application ... >
    <receiver android:name="com.example.android.tvleanback.BootupActivity"
              android:enabled="true"
              android:exported="false">
      <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
      </intent-filter>
    </receiver>
  </application>
</manifest>

Wichtig:Wenn Sie eine Benachrichtigung zum abgeschlossenen Bootmodus erhalten, muss Ihre App fordert die Berechtigung RECEIVE_BOOT_COMPLETED an. Weitere Informationen findest du unter ACTION_BOOT_COMPLETED.

In Ihrer Empfehlungsdienstklasse onHandleIntent() an den Manager senden:

Kotlin

val notification = notificationBuilder.build()
notificationManager.notify(id, notification)

Java

Notification notification = notificationBuilder.build();
notificationManager.notify(id, notification);
Zurück
Videovorschau