Buka konsol

Mengaktifkan Pengindeksan Konten Pribadi

Dengan pengindeksan konten pribadi, aplikasi Anda memberikan hasil penelusuran di aplikasi Google untuk konten yang terkait dengan akun pengguna. Pengguna hanya melihat konten pribadi di perangkatnya dalam saran penelusuran dan hasil penelusuran personal.

Misalnya, jika pengguna mencari "resep ayam favorit", tab hasil penelusuran personal berisi catatan yang ia tambahkan ke resep ayam dalam aplikasi resep.

Jika aplikasi tidak menyertakan konten pribadi, Anda dapat melewati langkah ini dan langsung membuka Membuat Log Tindakan Pengguna.

Sebelum memulai, pastikan Anda mendukung link ke konten aplikasi dan telah menambahkan library App Indexing ke aplikasi Anda.

Membangun indeks dan menambahkan objek

Buat class yang menggunakan ekstensi JobIntentService. Implementasi yang diuraikan dalam dokumentasi ini bergantung pada class JobIntentService untuk mengantrekan update ke indeks pada perangkat. Walau begitu, Anda dapat menggunakan class alternatif untuk menjadwalkan pekerjaan. Jika Anda mengikuti implementasi yang menggunakan class JobIntentService, pastikan juga untuk menambahkan Android Support Library ke file build.gradle project Anda.

Selanjutnya, untuk menyertakan item dalam indeks konten pribadi pada aplikasi, buat objek Indexable di class yang sama:

Jenis hasil

Dengan App Indexing, Anda dapat menampilkan hasil dengan dua cara:

  • Teks saja: Google Penelusuran menampilkan konten yang diindeks sebagai hasil teks.
  • Slices: Google Penelusuran menggunakan Slices atau template UI dari aplikasi Anda untuk memberikan hasil penelusuran yang dinamis dan interaktif.

Anda dapat memilih jenis hasil mana saja yang paling sesuai dengan aplikasi Anda. Hasil teks saja tidak seberapa rumit untuk diimplementasikan, tetapi Slice memberikan pengalaman pengguna yang lebih lengkap.

Contoh penerapan

Hasil teks saja

Java

public class AppIndexingUpdateService extends JobIntentService {

    // Job-ID must be unique across your whole app.
    private static final int UNIQUE_JOB_ID = 42;

    public static void enqueueWork(Context context) {
        enqueueWork(context, AppIndexingUpdateService.class, UNIQUE_JOB_ID, new Intent());
    }

    @Override
    protected void onHandleWork(@NonNull Intent intent) {
        // TODO Insert your Indexable objects — for example, the recipe notes look as follows:

        ArrayList<Indexable> indexableNotes = new ArrayList<>();

        for (Recipe recipe : getAllRecipes()) {
            Note note = recipe.getNote();
            if (note != null) {
                Indexable noteToIndex = Indexables.noteDigitalDocumentBuilder()
                        .setName(recipe.getTitle() + " Note")
                        .setText(note.getText())
                        .setUrl(recipe.getNoteUrl())
                        .build();

                indexableNotes.add(noteToIndex);
            }
        }

        if (indexableNotes.size() > 0) {
            Indexable[] notesArr = new Indexable[indexableNotes.size()];
            notesArr = indexableNotes.toArray(notesArr);

            // batch insert indexable notes into index
            FirebaseAppIndex.getInstance().update(notesArr);
        }
    }

    // ...
}

Kotlin

class AppIndexingUpdateService : JobIntentService() {

    companion object {

        // Job-ID must be unique across your whole app.
        private const val UNIQUE_JOB_ID = 42

        fun enqueueWork(context: Context) {
            enqueueWork(context, AppIndexingUpdateService::class.java, UNIQUE_JOB_ID, Intent())
        }
    }

    override fun onHandleWork(intent: Intent) {
        // TODO Insert your Indexable objects — for example, the recipe notes look as follows:

        val indexableNotes = arrayListOf<Indexable>()

        for (recipe in getAllRecipes()) {
            val note = recipe.note
            if (note != null) {
                val noteToIndex = Indexables.noteDigitalDocumentBuilder()
                        .setName(recipe.title + " Note")
                        .setText(note.text)
                        .setUrl(recipe.noteUrl)
                        .build()

                indexableNotes.add(noteToIndex)
            }
        }

        if (indexableNotes.size > 0) {
            val notesArr: Array<Indexable> = indexableNotes.toTypedArray()

            // batch insert indexable notes into index
            FirebaseAppIndex.getInstance().update(*notesArr)
        }
    }

    // ...
}
Hasil Slice

Dengan Slice, Anda dapat menentukan bagian dari aplikasi Anda yang muncul untuk merespons kueri Google Penelusuran. Slice bertindak sebagai UI untuk konten dalam Indexables Anda, sehingga setiap Slice harus langsung dipetakan ke Indexable. Ikuti langkah-langkah berikut untuk menghasilkan hasil penelusuran yang didukung Slice untuk aplikasi Anda:

  1. Tambahkan Slice ke aplikasi Anda dengan mengikuti petunjuk di panduan memulai Slice.
  2. Tambahkan Indexables dengan metadata dan listener Slice:
package com.example.myapp;

import android.content.Context;
import android.content.Intent;
import android.support.annotation.NonNull;
import android.support.v4.app.JobIntentService;
import com.google.firebase.appindexing.builders.Indexables;
import com.google.firebase.appindexing.FirebaseAppIndex;
import com.google.firebase.appindexing.Indexable;
import java.util.ArrayList;

public class AppIndexingUpdateService extends JobIntentService {
  // Job-ID must be unique across your whole app.
  private static final int UNIQUE_JOB_ID = 42;

  public static void enqueueWork(Context context) {
    enqueueWork(context, AppIndexingUpdateService.class, UNIQUE_JOB_ID, new Intent());
  }

  @Override
  protected void onHandleWork(@NonNull Intent intent) {
    // TODO Insert your Indexable objects — for example, the recipe notes look as follows:

    ArrayList<Indexable> indexableNotes = new ArrayList<>();

    for (Recipe recipe : getAllRecipes()) {
        Note note = recipe.getNote();
        if (note != null) {
            Indexable noteToIndex = Indexables.noteDigitalDocumentBuilder()
                    .setName(recipe.getTitle() + " Note")
                    .setText(note.getText())
                    .setUrl(recipe.getNoteUrl())
                    .setMetadata(
                      new Indexable.Metadata.Builder().setSliceUri(
                        Uri.parse("content://com.example.myapp.sliceprovider/note?id=" +
                                  recipe.getNoteId())
                    ))
                    .build();

            indexableNotes.add(noteToIndex);
        }
    }

    if (indexableNotes.size() > 0) {
        Indexable[] notesArr = new Indexable[indexableNotes.size()];
        notesArr = indexableNotes.toArray(notesArr);

        // batch insert indexable notes into index
        FirebaseAppIndex.getInstance().update(notesArr)
                        .addOnSuccessListener(unused -> {
                          Log.d("RecipeApp", "Update succeeded!");
                        })
                        .addOnFailureListener(exception -> {
                          Log.d("RecipeApp", "Update failed: " + exception);
                        });
    }
  }
}

Apa yang harus ada dalam indeks konten pribadi?

Tentukan objek Indexable untuk jenis konten berikut:

  • Konten khusus pengguna, seperti pesan, foto, atau dokumen.
  • Konten yang penting bagi pengguna, seperti favorit atau konten yang mungkin ingin diakses lebih sering. Misalnya, dokumen atau lagu yang telah diberi bookmark atau ditandai untuk penggunaan offline.
  • Konten yang dihasilkan dalam aplikasi, bukan hanya diakses oleh aplikasi. Misalnya, kontak yang dibuat oleh pengguna secara langsung di aplikasi, dan disimpan oleh aplikasi Anda, bukan kontak dari direktori ponsel.

Menambahkan penerima siaran ke aplikasi Anda

Layanan Google Play secara berkala mengirimkan permintaan ke aplikasi Anda untuk mengupdate indeks pada perangkat. Dengan demikian, indeks pada perangkat akan memiliki konten terbaru dari aplikasi Anda. Class BroadcastReceiver menerima permintaan dan memicu JobIntentService untuk memproses tugas pengindeksan. Contoh di bawah ini menggunakan class AppIndexingUpdateService dari langkah sebelumnya.

Java

/** Receives broadcast for App Indexing Update. */
public class AppIndexingUpdateReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null
                && FirebaseAppIndex.ACTION_UPDATE_INDEX.equals(intent.getAction())) {
            // Schedule the job to be run in the background.
            AppIndexingUpdateService.enqueueWork(context);
        }
    }

}

Kotlin

/** Receives broadcast for App Indexing Update. */
class AppIndexingUpdateReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent?) {
        if (intent != null && FirebaseAppIndex.ACTION_UPDATE_INDEX == intent.action) {
            // Schedule the job to be run in the background.
            AppIndexingUpdateService.enqueueWork(context)
        }
    }
}

Menghasilkan dan memuat ulang indeks

Selanjutnya, izinkan layanan Google Play memanggil layanan Pengindeksan Aplikasi untuk mengupdate indeks pada perangkat dengan konten pribadi pengguna dalam 3 situasi berikut:

  • Ketika aplikasi diinstal di perangkat.
  • Jika versi aplikasi yang ada diupdate ke versi yang mendukung pengindeksan konten pribadi.
  • Panggilan berkala dari waktu ke waktu untuk mencerminkan perubahan yang terjadi pada konten yang diindeks secara akurat, dan memastikan pengalaman yang sempurna bagi pengguna.

Selain itu, jika indeks pada perangkat hilang karena alasan apa pun (misalnya, jika indeks rusak), panggilan untuk memperbarui indeks ini akan terisi kembali.

Di file AndroidManifest.xml Anda, daftarkan BroadcastReceiver agar indeks dapat menerima panggilan dari Layanan Google Play untuk memperbarui indeks. Contoh di bawah ini menggunakan class JobIntentService untuk menjadwalkan pembaruan pengindeksan:

<!-- Register the BroadcastReceiver -->
<receiver
    android:name=".AppIndexingUpdateReceiver"
    android:exported="true"
    android:permission="com.google.android.gms.permission.APPINDEXING">
    <intent-filter>
        <action android:name="com.google.firebase.appindexing.UPDATE_INDEX" />
    </intent-filter>
</receiver>

<!-- Grant the AppIndexingUpdateService permission and enable it to run after being triggered -->
<service
    android:name=".AppIndexingUpdateService"
    android:permission="android.permission.BIND_JOB_SERVICE" />

Mengupdate indeks

Ketika pengguna menambahkan, mengupdate, atau menghapus konten pribadinya, indeks pada perangkat harus mencerminkan perubahan tersebut. Tambahkan kode berikut untuk mengupdate konten di indeks:

Mengupdate teks saja

Java

public void indexNote(Recipe recipe) {
    Note note = recipe.getNote();
    Indexable noteToIndex = Indexables.noteDigitalDocumentBuilder()
            .setName(recipe.getTitle())
            .setText(note.getText())
            .setUrl(recipe.getNoteUrl())
            .build();

    Task<Void> task = FirebaseAppIndex.getInstance().update(noteToIndex);
    // ...
}

Kotlin

fun indexNote(recipe: Recipe) {
    val note = recipe.note
    val noteToIndex = Indexables.noteDigitalDocumentBuilder()
            .setName(recipe.title)
            .setText(note!!.text)
            .setUrl(recipe.noteUrl)
            .build()

    val task = FirebaseAppIndex.getInstance().update(noteToIndex)
    // ...
}
Mengupdate Slice

Firebase App Indexing mengambil konten Slice pada waktu pengindeksan, menyimpannya, dan memunculkan snapshot Slice pada waktu kueri. Jika konten Slice berubah antara pengindeksan dan pembuatan kueri, snapshot tersebut bisa menyesatkan atau membingungkan bagi pengguna. Untuk menghindarinya, update Slice dan indeks ulang Indexable pada saat yang bersamaan, sehingga Firebase App Indexing selalu memiliki konten Slice terbaru.

private void indexNote() {
  Note note = mRecipe.getNote();
  Indexable noteToIndex = Indexables.noteDigitalDocumentBuilder()
          .setName(mRecipe.getTitle())
          .setText(note.getText())
          .setUrl(mRecipe.getNoteUrl())
          .setKeywords("recipe", "cooking")
          .setMetadata(
              new Indexable.Metadata.Builder().setSliceUri(
              Uri.parse("content://com.example.myapp.sliceprovider/note?id=" + note.getNoteId())))
          .build();

  Task<Void> task = FirebaseAppIndex.getInstance().update(noteToIndex);
   ...
}
Menghapus

Untuk mengidentifikasi item yang harus dihapus, gunakan URL item. Tambahkan baris berikut ke fungsi hapus di aplikasi Anda untuk item tersebut.

Java

// Deletes or removes the corresponding notes from index.
String noteUrl = recipe.getNoteUrl();
FirebaseAppIndex.getInstance().remove(noteUrl);

Kotlin

// Deletes or removes the corresponding notes from index.
val noteUrl = recipe.noteUrl
FirebaseAppIndex.getInstance().remove(noteUrl)

Menghapus indeks ketika pengguna logout

Hapus indeks pada perangkat ketika pengguna logout dari aplikasi, pada peristiwa logout. Sertakan panggilan untuk membuat dan memuat ulang indeks menggunakan AppIndexingService untuk mengisi kembali indeks pada perangkat saat pengguna kembali login.

Untuk menghapus indeks pada perangkat ketika pengguna logout dari aplikasi Anda, tambahkan kode berikut ke aplikasi tersebut:

Java

FirebaseAppIndex.getInstance().removeAll();

Kotlin

FirebaseAppIndex.getInstance().removeAll()

Berikutnya: Membuat Log Tindakan Pengguna