Pakiet SDK dla klientów indywidualnych na Androida

Za pomocą pakietu SDK dla konsumentów możesz utworzyć i uruchomić podstawową, zintegrowaną aplikację z usługami backendu rozwiązań w zakresie przejazdów i dostaw na żądanie. Możesz utworzyć aplikację Podróż i Postęp przetwarzania zamówienia, która może wyświetlać aktywną podróż, reagować na aktualizacje podróży i eliminować błędy związane z podróżami.

Pakiet SDK Consumer SDK ma architekturę modułową, można więc używać części interfejsu API, którego chcesz używać z konkretną aplikacją, i zintegruj je z własnymi interfejsami API, usługami backendu dostępnymi przez Fleet Engine i dodatkowych interfejsów API w Google Maps Platform.

Minimalne wymagania systemowe

Na urządzeniu mobilnym musi być zainstalowany Android. 6,0 (poziom interfejsu API 23) lub nowszy.

Konfiguracja kompilacji i zależności

Pakiet SDK dla klientów indywidualnych w wersji 1.99.0 lub nowszej jest dostępny za pomocą narzędzia Google Maven z repozytorium. Używany wcześniej kanał repozytorium prywatnego został wycofany.

Gradle

Dodaj do pliku build.gradle te informacje:

repositories {
    ...
    google()
}

Maven

Dodaj do pliku pom.xml te informacje:

<project>
  ...
  <repositories>
    <repository>
      <id>google-maven-repository</id>
      <url>https://maven.google.com</url>
    </repository>
  </repositories>
  ...
</project>

Konfiguracja projektu

Aby można było używać pakietu SDK dla użytkowników Androida, aplikacja musi być kierowana minSdkVersion w wersji 23 lub nowszej.

Aby uruchomić aplikację stworzoną za pomocą pakietu SDK dla klientów indywidualnych, urządzenie musi mieć Usługi Google Play Zainstalowano.

Konfigurowanie projektu programistycznego

Aby skonfigurować projekt programistyczny i uzyskać klucz interfejsu API dla projektu w konsoli Google Cloud:

  1. Utwórz nowy projekt konsoli Google Cloud lub wybierz istniejący projekt, którego chcesz użyć. za pomocą pakietu Consumer SDK. Zaczekaj kilka minut do nowy projekt będzie widoczny w konsoli Google Cloud.

  2. Aby można było uruchomić aplikację w wersji demonstracyjnej, projekt musi mieć dostęp do pakietu SDK Maps na Androida. W konsoli Google Cloud wybierz Interfejsy API Usługi > Library, a następnie wyszukaj i włącz pakiet SDK Maps dla na urządzeniu z Androidem.

  3. Wybierz, aby pobrać klucz interfejsu API dla projektu Interfejsy API Usługi > Dane logowania > Utwórz dane logowania > API. Więcej informacji o uzyskiwaniu klucza interfejsu API znajdziesz w artykule Uzyskaj klucz interfejsu API.

Dodaj do aplikacji pakiet SDK dla klientów indywidualnych

Pakiet SDK dla klientów indywidualnych jest dostępny w prywatnym repozytorium Maven. repozytorium zawiera pliki .pom (Project Object Model) pakietu SDK i dokumenty Javadocs. Aby dodać do aplikacji pakiet SDK dla konsumentów:

  1. Skonfiguruj środowisko, aby uzyskać dostęp do repozytorium Maven hosta zgodnie z opisem w sekcji poprzedniej sekcji.

    Jeśli masz zadeklarowaną scentralizowaną konfigurację zarządzania zależnościami w settings.gradle, wyłącz go w następujący sposób.

    • Usuń w settings.gradle ten blok kodu:

      import org.gradle.api.initialization.resolve.RepositoriesMode
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

  2. Dodaj poniższą zależność do konfiguracji Gradle lub Maven, zastępując Obiekt zastępczy VERSION_NUMBER, który wskazuje odpowiednią wersję pakietu Consumer SDK.

    Gradle

    Dodaj do build.gradle:

    dependencies {
  ...
  implementation 'com.google.android.libraries.mapsplatform.transportation:transportation-consumer:VERSION_NUMBER'
}

    Maven

    Dodaj do pom.xml:

    <dependencies>
  ...
  <dependency>
    <groupId>com.google.android.libraries.mapsplatform.transportation</groupId>
    <artifactId>transportation-consumer</artifactId>
    <version>VERSION_NUMBER</version>
  </dependency>
</dependencies>

  3. Pakiet SDK dla klientów indywidualnych korzysta z pakietu Maps SDK. Ta zależność jest skonfigurowana w taki sposób w taki sposób, że jeśli wersja pakietu Maps SDK nie jest wyraźnie zdefiniowana w pliku konfiguracji kompilacji, jak widać poniżej. SDK dla klientów indywidualnych będzie w dalszym ciągu wykorzystywać minimalne wymagana wersja pakietu SDK Map Google.

    Gradle

    Dodaj do build.gradle:

    dependencies {
  ...
  implementation 'com.google.android.gms:play-services-maps:18.1.0'
}

    Maven

    Dodaj do pom.xml:

    <dependencies>
  ...
  <dependency>
    <groupId>com.google.android.gms</groupId>
    <artifactId>play-services-maps</artifactId>
    <version>18.1.0</version>
  </dependency>
</dependencies>

Dodawanie klucza interfejsu API do aplikacji

Po dodaniu do aplikacji pakietu Consumer SDK dodaj do niej klucz interfejsu API. Musisz użyć klucza interfejsu API projektu uzyskanego podczas skonfigurować projekt programistyczny.

W tej sekcji opisano, jak przechowywać klucz interfejsu API w celu zwiększenia jego bezpieczeństwa przywoływanych przez aplikację. Nie sprawdzaj klucza interfejsu API w swojej wersji systemu sterowania. Powinien on być zapisany w pliku local.properties, który jest znajduje się w katalogu głównym projektu. Więcej informacji na temat local.properties, patrz Pliki właściwości Gradle.

Aby uprościć to zadanie, możesz skorzystać z Wtyczka Gradle obiektów tajnych na Androida.

Aby zainstalować wtyczkę i zapisać klucz interfejsu API:

  1. Otwórz plik build.gradle na poziomie głównym i dodaj ten kod do sekcji dependencies w kolumnie buildscript.

    Zakręcony

    buildscript {
    dependencies {
        // ...
        classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.0"
    }
}

    Kotlin

    buildscript {
    dependencies {
        // ...
        classpath("com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.0")
    }
}

  2. Otwórz plik build.gradle na poziomie aplikacji i dodaj ten kod do sekcji plugins.

    Zakręcony

    id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'

    Kotlin

    id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")

  3. Jeśli używasz Androida Studio, zsynchronizować projekt z Gradle.

  4. Otwórz local.properties w katalogu na poziomie projektu i dodaj do tego kodu. Zastąp YOUR_API_KEY swoim kluczem interfejsu API.

    MAPS_API_KEY=YOUR_API_KEY

  5. W pliku AndroidManifest.xml przejdź do sekcji com.google.android.geo.API_KEY i zaktualizuj atrybut android:value w następujący sposób:

    <meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="${MAPS_API_KEY}" />

Ten przykład zawiera pełny plik manifestu przykładowej aplikacji:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.consumerapidemo">
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/_AppTheme">

        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="${MAPS_API_KEY}" />

        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Umieść w aplikacji wymagane informacje o źródłach

Jeśli w swojej aplikacji używasz pakietu SDK dla konsumentów, musisz dołączyć tekstu informacji o źródle i licencji open source jako część informacji prawnych dotyczących aplikacji. . Informacje o autorach najlepiej jest dodawać jako niezależną pozycję menu lub jako w menu Informacje.

Informacje o licencjach można znaleźć w pliku „third_party_licenses.txt”. zapisz w niezarchiwizowanego pliku AAR.

Wejdź na https://developers.google.com/android/guides/opensource. jak uwzględniać powiadomienia open source.

Uwierzytelnianie za pomocą pakietu SDK klienta

Pakiet SDK Consumer SDK umożliwia uwierzytelnianie za pomocą tokenów sieciowych JSON. Token internetowy JSON (JWT) to podstawowy token dostępu JSON, który zapewnia lub więcej roszczeń dotyczących usługi. Serwer może na przykład wygenerować token z roszczeniem „zalogował się jako administrator” i dostarczają klientowi. Klient może następnie użyć tego tokena, aby udowodnić, że jest zalogowany jako administrator.

Pakiet SDK klienta korzysta z tokena internetowego JSON udostępnionego przez aplikację komunikacją z Fleet Engine. Więcej informacji znajdziesz w artykule Uwierzytelnianie i autoryzacja Fleet Engine.

Token autoryzacji musi zawierać deklarację tripid:TRIP_ID w authorization, gdzie TRIP_ID to identyfikator podróży. Dzięki temu konsument Dostęp pakietu SDK do szczegółów podróży, takich jak pozycja pojazdu, trasa i szacowany czas dotarcia na miejsce.

Wywołania zwrotne tokena internetowego JSON

Pakiet SDK klienta rejestruje wywołanie zwrotne tokena autoryzacji z aplikacją podczas inicjowania. Pakiet SDK wywołuje aplikację aby uzyskać token dla wszystkich żądań sieciowych, które wymagają autoryzacji.

Zdecydowanie zalecamy, aby implementacja wywołania zwrotnego była autoryzowana w pamięci podręcznej i odświeżać je dopiero po upływie czasu expiry. Tokeny powinny być wydawane z godzinną datą ważności.

Wywołanie zwrotne tokena autoryzacji określa wymagany token usługi dla usługi TripService. Zapewnia też wymagane tripId w kontekście.

Poniższy przykładowy kod pokazuje, jak wdrożyć autoryzację wywołanie zwrotne tokena.

Java

class JsonAuthTokenFactory implements AuthTokenFactory {

  private static final String TOKEN_URL =
      "https://yourauthserver.example/token";

  private static class CachedToken {
    String tokenValue;
    long expiryTimeMs;
    String tripId;
  }

  private CachedToken token;

  /*
  * This method is called on a background thread. Blocking is OK. However, be
  * aware that no information can be obtained from Fleet Engine until this
  * method returns.
  */
  @Override
  public String getToken(AuthTokenContext context) {
    // If there is no existing token or token has expired, go get a new one.
    String tripId = context.getTripId();
    if (tripId == null) {
      throw new RuntimeException("Trip ID is missing from AuthTokenContext");
    }
    if (token == null || System.currentTimeMillis() > token.expiryTimeMs ||
        !tripId.equals(token.tripId)) {
      token = fetchNewToken(tripId);
    }
    return token.tokenValue;
  }

  private static CachedToken fetchNewToken(String tripId) {
    String url = TOKEN_URL + "/" + tripId;
    CachedToken token = new CachedToken();

    try (Reader r = new InputStreamReader(new URL(url).openStream())) {
      com.google.gson.JsonObject obj
          = com.google.gson.JsonParser.parseReader(r).getAsJsonObject();

      token.tokenValue = obj.get("ServiceToken").getAsString();
      token.expiryTimeMs = obj.get("TokenExpiryMs").getAsLong();

      /*
      * The expiry time could be an hour from now, but just to try and avoid
      * passing expired tokens, we subtract 5 minutes from that time.
      */
      token.expiryTimeMs -= 5 * 60 * 1000;
    } catch (IOException e) {
      /*
      * It's OK to throw exceptions here. The error listeners will receive the
      * error thrown here.
      */
      throw new RuntimeException("Could not get auth token", e);
    }
    token.tripId = tripId;

    return token;
  }
}

Kotlin

class JsonAuthTokenFactory : AuthTokenFactory() {

  private var token: CachedToken? = null

  /*
  * This method is called on a background thread. Blocking is OK. However, be
  * aware that no information can be obtained from Fleet Engine until this
  * method returns.
  */
  override fun getToken(context: AuthTokenContext): String {
    // If there is no existing token or token has expired, go get a new one.
    val tripId = 
      context.getTripId() ?: 
        throw RuntimeException("Trip ID is missing from AuthTokenContext")

    if (token == null || System.currentTimeMillis() > token.expiryTimeMs ||
        tripId != token.tripId) {
      token = fetchNewToken(tripId)
    }

    return token.tokenValue
  }

  class CachedToken(
    var tokenValue: String? = "", 
    var expiryTimeMs: Long = 0,
    var tripId: String? = "",
  )

  private companion object {
    const val TOKEN_URL = "https://yourauthserver.example/token"

    fun fetchNewToken(tripId: String) {
      val url = "$TOKEN_URL/$tripId"
      val token = CachedToken()

      try {
        val reader = InputStreamReader(URL(url).openStream())

        reader.use {
          val obj = com.google.gson.JsonParser.parseReader(r).getAsJsonObject()

          token.tokenValue = obj.get("ServiceToken").getAsString()
          token.expiryTimeMs = obj.get("TokenExpiryMs").getAsLong()

          /*
          * The expiry time could be an hour from now, but just to try and avoid
          * passing expired tokens, we subtract 5 minutes from that time.
          */
          token.expiryTimeMs -= 5 * 60 * 1000
        }
      } catch (e: IOException) {
        /*
        * It's OK to throw exceptions here. The error listeners will receive the
        * error thrown here.
        */
        throw RuntimeException("Could not get auth token", e)
      }

      token.tripId = tripId

      return token
    }
  }
}

Inicjowanie interfejsu API

Przed wykonaniem tych procedur zakładamy, że włączona jest opcja odpowiednich usług i pakietu Consumer SDK.

Pobieranie instancji ConsumerApi

Aby można było używać pakietu SDK dla użytkowników indywidualnych, aplikacja musi zostać zainicjowana ConsumerApi asynchronicznie. Interfejs API to jedyny system. Metoda inicjowania zajmuje AuthTokenFactory. Fabryka produkuje nowe Tokeny JWT dla użytkownika, gdy jest to konieczne.

providerId to identyfikator projektu Google Cloud. Zobacz Przewodnik użytkownika Fleet Engine .

Aplikacja powinna implementować interfejs AuthTokenFactory w sposób opisany w Uwierzytelnianie klienta za pomocą pakietu SDK.

Java

Task<ConsumerApi> consumerApiTask = ConsumerApi.initialize(
    this, "myProviderId", authTokenFactory);

consumerApiTask.addOnSuccessListener(
  consumerApi -> this.consumerApi = consumerApi);

Kotlin

val consumerApiTask =
  ConsumerApi.initialize(this, "myProviderId", authTokenFactory)

consumerApiTask?.addOnSuccessListener { consumerApi: ConsumerApi ->
  this@YourActivity.consumerApi = consumerApi
}

Maps SDK i mechanizmy renderowania map

Pakiet Consumer SDK w wersji 2.x.x obsługuje pakiet Maps SDK na Androida w wersji 18.1.0 lub nowszej. Tabela poniżej podsumowuje domyślny mechanizm renderowania według wersji pakietu SDK Map Google oraz możliwości obu mechanizmów renderowania. Zalecamy jednak użycie najnowszego mechanizmu renderowania, z użyciem starszego mechanizmu renderowania, możesz go wyraźnie określić za pomocą MapsInitializer.initialize()

Wersja pakietu SDK Maps Obsługuje najnowszy mechanizm renderowania Obsługuje starszy mechanizm renderowania Domyślny mechanizm renderowania
Wersja 18.1.0 i starsze Tak Tak Starsza wersja*
V18.2.0 Tak Tak Najnowsze

* Po wdrożeniu nowego mechanizmu renderowania Map, domyślny mechanizm renderowania.

Dodaj pakiet Maps SDK jako zależność

Gradle

Dodaj do build.gradle:

dependencies {
  //...
  implementation "com.google.android.gms:play-services-maps:VERSION_NUMBER"
}

Maven

Dodaj do pom.xml:

 <dependencies>
   ...
   <dependency>
     <groupId>com.google.android.gms</groupId>
     <artifactId>play-services-maps</artifactId>
     <version>18.1.0</version>
   </dependency>
 </dependencies>

Zainicjuj pakiet SDK Maps SDK przed zainicjowaniem pakietu dla klientów indywidualnych

W ramach zajęć Application lub start-upów Activity zadzwoń MapsInitializer.initialize() i poczekaj na wynik żądania mechanizmu renderowania, zanim zainicjujesz pakiet SDK dla klientów indywidualnych.

java

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  initViews();

  MapsInitializer.initialize(getApplicationContext(), Renderer.LATEST,
      new OnMapsSdkInitializedCallback() {
        @Override
        public void onMapsSdkInitialized(Renderer renderer) {
          switch (renderer) {
            case LATEST:
              Log.i("maps_renderer", "LATEST renderer");
              break;
            case LEGACY:
              Log.i("maps_renderer", "LEGACY renderer");
              break;
          }

          initializeConsumerSdk();
        }
      });
}

Kotlin

fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.main)
  initViews()

  MapsInitializer.initialize(
    getApplicationContext(), Renderer.LATEST,
    object : OnMapsSdkInitializedCallback() {
      fun onMapsSdkInitialized(renderer: Renderer?) {
        when (renderer) {
          LATEST -> Log.i("maps_renderer", "LATEST renderer")
          LEGACY -> Log.i("maps_renderer", "LEGACY renderer")
        }
        initializeConsumerSdk()
      }
    })
  }

Tworzenie interfejsu użytkownika

Możesz użyć: ConsumerMapFragment lub ConsumerMapView, aby utworzyć interfejs użytkownika aplikacji. Funkcja ConsumerMapFragment umożliwia określenie za pomocą Fragment, natomiast ConsumerMapView umożliwia korzystanie z View Wspólne przejazdy funkcje są takie same zarówno w ConsumerMapView, jak i ConsumerMapFragment, aby wybrać tę usługę na podstawie czy View, czy Fragment jest lepszy w przypadku Twojej aplikacji.

Dodanie obsługi elementów rysowanych w interfejsie API 19 (KitKat) i wektorowych

Jeśli projekt Twojej aplikacji wymaga obsługi urządzeń z interfejsem API 19 (KitKat) i elementów rysowanych wektorowo, dodaj następujący kod do swojej aktywności. Ten kod przedłuża się AppCompatActivity, aby użyć Obiekty rysowalne wektorowe w pakiecie SDK dla klientów indywidualnych.

Java

// ...
import android.support.v7.app.AppCompatActivity;

// ...

public class ConsumerTestActivity extends AppCompatActivity {
  // ...
}

Kotlin

// ...
import android.support.v7.app.AppCompatActivity

// ...

class ConsumerTestActivity : AppCompatActivity() {
  // ...
}

Dodawanie fragmentu lub widoku mapy

Tworzysz mapę do wyświetlania dzielenia się podróżami we fragmencie Androida lub widoku zdefiniowanego w pliku XML układu aplikacji (znajdujący się w /res/layout). Następnie fragment (lub widok) zapewnia dostęp do podróży. udostępnianie mapy, której aplikacja może używać i modyfikować. Mapa zapewnia też dostęp do funkcji do interfejsu ConsumerController, który umożliwia aplikacji kontrolowanie dostosować środowisko udostępniania.

Udostępnianie mapy i kontrolera

Mapę udostępniania podróży definiuje się jako fragment (za pomocą ConsumerMapFragment) lub jako widok (za pomocą ConsumerMapView), jak pokazano w poniżej przykładowego kodu. Twoja metoda onCreate() powinna następnie wywołać getConsumerGoogleMapAsync(callback), która zwraca ConsumerGoogleMap asynchronicznie w wywołaniu zwrotnym. Następnie możesz użyć funkcji ConsumerGoogleMap, aby wyświetlić i można je aktualizować w zależności od potrzeb aplikacji.

ConsumerMapFragment

Definiujesz fragment w pliku XML układu aplikacji, jak pokazano na ten przykładowy kod.

<fragment
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="com.google.android.libraries.mapsplatform.transportation.consumer.view.ConsumerMapFragment"
    android:id="@+id/consumer_map_fragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Wywołanie funkcji getConsumerGoogleMapAsync() powinno pochodzić z aplikacji onCreate() .

Java

public class SampleAppActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {

    // Find the ConsumerMapFragment.
    ConsumerMapFragment consumerMapFragment =
        (ConsumerMapFragment) fragmentManager.findFragmentById(R.id.consumer_map_fragment);

    // Initiate the callback that returns the map.
    if (consumerMapFragment != null) {
      consumerMapFragment.getConsumerGoogleMapAsync(
          new ConsumerMapReadyCallback() {
            // The map returned in the callback is used to access the ConsumerController.
            @Override
            public void onConsumerMapReady(@NonNull ConsumerGoogleMap consumerGoogleMap) {
              ConsumerController consumerController = consumerGoogleMap.getConsumerController();
            }
          });
    }
  }

}

Kotlin

class SampleAppActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    // Find the ConsumerMapFragment.
    val consumerMapFragment =
      fragmentManager.findFragmentById(R.id.consumer_map_fragment) as ConsumerMapFragment

    consumerMapFragment.getConsumerGoogleMapAsync(
      object : ConsumerMapReadyCallback() {
        override fun onConsumerMapReady(consumerGoogleMap: ConsumerGoogleMap) {
          val consumerController = consumerGoogleMap.getConsumerController()!!
        }
      }
    )
  }
}
ConsumerMapView

Widok może być używany we fragmencie lub w aktywności, zgodnie z definicją XML.

<com.google.android.libraries.mapsplatform.transportation.consumer.view.ConsumerMapView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/consumer_map_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Wywołanie getConsumerGoogleMapAsync() powinno pochodzić z onCreate(). W oprócz parametru wywołania zwrotnego wymagany jest element zawierający aktywność lub fragment i GoogleMapOptions (który może mieć wartość null), który zawiera konfigurację dla: MapView. Klasa bazowa aktywności lub fragmentu musi być albo FragmentActivity lub pomocy Fragment, ponieważ zapewniają i dostęp do jej cyklu życia.

Java

public class SampleAppActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    ConsumerMapView mapView = findViewById(R.id.consumer_map_view);

    if (mapView != null) {
      mapView.getConsumerGoogleMapAsync(
          new ConsumerMapReadyCallback() {
            // The map returned in the callback is used to access the ConsumerController.
            @Override
            public void onConsumerMapReady(@NonNull ConsumerGoogleMap consumerGoogleMap) {
              ConsumerController consumerController = consumerGoogleMap.getConsumerController();
            }
          }, this, null);
    }
  }

}

Kotlin

class SampleAppActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    val mapView = findViewById(R.id.consumer_map_view) as ConsumerMapView

    mapView.getConsumerGoogleMapAsync(
      object : ConsumerMapReadyCallback() {
        // The map returned in the callback is used to access the ConsumerController.
        override fun onConsumerMapReady(consumerGoogleMap: ConsumerGoogleMap) {
          val consumerController = consumerGoogleMap.getConsumerController()!!
        }
      },
      /* fragmentActivity= */ this,
      /* googleMapOptions= */ null,
    )
  }
}

Pozycja MapView we fragmencie jest taka sama jak w przykładzie powyżej dla MapView w z tą różnicą, że fragment rozszerza układ zawierający MapView we fragmencie onCreateView().

Java

public class MapViewInFragment extends Fragment {

  @Override
  public View onCreateView(
      @NonNull LayoutInflater layoutInflater,
      @Nullable ViewGroup viewGroup,
      @Nullable Bundle bundle) {
    return layoutInflater.inflate(R.layout.consumer_map_view, viewGroup, false);
  }

}

Kotlin

class MapViewInFragment : Fragment() {
  override fun onCreateView(
    layoutInflater: LayoutInflater,
    container: ViewGroup?,
    savedInstanceState: Bundle?,
  ): View {
    return layoutInflater.inflate(R.layout.consumer_map_view, viewGroup, false)
  }
}

Dostosowywanie powiększenia aparatu w celu skoncentrowania się na podróży

Domyślny przycisk Moja lokalizacja wbudowany w pakiet SDK Map Google kieruje aparat na lokalizację urządzenia.

Jeśli trwa sesja udostępniania trasy, możesz wyśrodkować kamerę aby skupić się na trasie, a nie na lokalizacji urządzenia.

Wbudowany pakiet SDK dla użytkowników urządzeń z Androidem: AutoCamera

Aby umożliwić Ci skupienie się na podróży, a nie na lokalizacji urządzenia, Pakiet SDK dla klientów indywidualnych udostępnia funkcję aparatu automatycznego, domyślnie włączone. Kamera robi zbliżenie, aby skupić się na trasie udostępniania podróży. następny punkt na trasie podróży.

AutoCamera

Dostosowywanie działania kamery

Jeśli chcesz mieć większą kontrolę nad działaniem kamery, możesz ją wyłączyć lub włączyć autokamerę za pomocą funkcji ConsumerController.setAutoCameraEnabled().

ConsumerController.getCameraUpdate() zwraca w danym momencie zalecane wartości progowe kamery. Możesz następnie podać ten element CameraUpdate jako argument dla GoogleMap.moveCamera() lub GoogleMap.animateCamera().

Korzystaj ze wspólnych przejazdów i map

Aby obsługiwać wspólne przejazdy i interakcję z mapą w aplikacji, musisz mieć dostęp do: ConsumerGoogleMap i ConsumerController ConsumerMapFragment i ConsumerMapView zwracają asynchronicznie ConsumerGoogleMap w: ConsumerMapReadyCallback. ConsumerGoogleMap za możliwość zwrotu ConsumerController od: getConsumerController(). Ty ma dostęp do ConsumerGoogleMap i ConsumerController w następujący sposób.

Java

private ConsumerGoogleMap consumerGoogleMap;
private ConsumerController consumerController;
private ConsumerMapView consumerMapView;

consumerMapView.getConsumerGoogleMapAsync(
    new ConsumerMapReadyCallback() {
      @Override
      public void onConsumerMapReady(@NonNull ConsumerGoogleMap consumerMap) {
        consumerGoogleMap = consumerMap;
        consumerController = consumerMap.getConsumerController();
      }
    },
    this, null);

Kotlin

var consumerGoogleMap: ConsumerGoogleMap
var consumerController: ConsumerController
val consumerMapView = findViewById(R.id.consumer_map_view) as ConsumerMapView

consumerMapView.getConsumerGoogleMapAsync(
  object : ConsumerMapReadyCallback() {
    override fun onConsumerMapReady(consumerMap: ConsumerGoogleMap) {
      consumerGoogleMap = consumerMap
      consumerController = consumerMap.getConsumerController()
    },
    /* fragmentActivity= */ this,
    /* googleMapOptions= */ null,
  }
)

ConsumerGoogleMap

ConsumerGoogleMap to klasa kodu dla tagu GoogleMap zajęcia. Dzięki niemu aplikacja może: interakcji z mapą za pomocą interfejsu API równoważnego GoogleMap Korzystanie z mapy konsumenta umożliwia aplikacji i korzystanie z transportu co umożliwia płynną interakcję z tą samą bazową mapą Google. Przykład: GoogleMap umożliwia rejestrację tylko z jednym wywołaniem zwrotnym, ale ConsumerGoogleMap obsługuje podwójne zarejestrowane wywołania zwrotne. Te wywołania zwrotne pozwalają aplikacji i udostępnianiu przejazdów rejestrować wywołania zwrotne, które są są wywoływane sekwencyjnie.

ConsumerController

ConsumerController umożliwia dostęp do funkcji wspólnych przejazdów, takich jak takich jak monitorowanie podróży, kontrolowanie ich stanu i ustawianie lokalizacji.

Konfigurowanie udostępniania podróży

Gdy backend dopasuje klienta do pojazdu, użyj funkcji JourneySharingSession aby rozpocząć korzystanie z interfejsu Udostępniania podróży. Udostępnianie serii wyświetla dopasowane lokalizację i trasę pojazdu. Po zaimplementowaniu pakietu SDK w aplikacji możesz dodać funkcje monitorowania podróży, nasłuchiwania aktualizacji i obsługi błędów. W poniższych procedurach zakładamy, że usługi backendu są dostępne i że usługi dopasowywania pojazdów do klientów.

  1. Zarejestruj detektor w obiekcie TripModel, aby uzyskać szczegółowe informacje o informacje o podróży, takie jak szacowany czas przyjazdu (szacowany czas przyjazdu) i odległość; który pojazd musi przejechać przed przyjazdem.

    Java

    // Create a TripModel instance for listening to updates to the trip specified by this trip name.
String tripName = ...;
TripModelManager tripModelManager = consumerApi.getTripModelManager();
TripModel tripModel = tripModelManager.getTripModel(tripName);

// Create a JourneySharingSession instance based on the TripModel.
JourneySharingSession session = JourneySharingSession.createInstance(tripModel);

// Add the JourneySharingSession instance on the map for updating the UI.
consumerController.showSession(session);

// Register for trip update events.
tripModel.registerTripCallback(new TripModelCallback() {
  @Override
  public void onTripETAToNextWaypointUpdated(
      TripInfo tripInfo, @Nullable Long timestampMillis) {
    // ...
  }

  @Override
  public void onTripActiveRouteRemainingDistanceUpdated(
      TripInfo tripInfo, @Nullable Integer distanceMeters) {
    // ...
  }

  // ...
});

    Kotlin

    // Create a TripModel instance for listening to updates to the trip specified by this trip name.
val tripName = "tripName"
val tripModelManager = consumerApi.getTripModelManager()
val tripModel = tripModelManager.getTripModel(tripName)

// Create a JourneySharingSession instance based on the TripModel.
val session = JourneySharingSession.createInstance(tripModel)

// Add the JourneySharingSession instance on the map for updating the UI.
consumerController.showSession(session)

// Register for trip update events.
tripModel.registerTripCallback(
  object : TripModelCallback() {
    override fun onTripETAToNextWaypointUpdated(
      tripInfo: TripInfo,
      timestampMillis: Long?,
    ) {
      // ...
    }

    override fun onTripActiveRouteRemainingDistanceUpdated(
      tripInfo: TripInfo,
      distanceMeters: Int?,
    ) {
      // ...
    }

  // ...
})

  2. Skonfiguruj podróż w aplikacji TripModelOptions.

    Java

    // Set refresh interval to 2 seconds.
TripModelOptions tripOptions =
    TripModelOptions.builder().setRefreshIntervalMillis(2000).build();
tripModel.setTripModelOptions(tripOptions);

    Kotlin

    // Set refresh interval to 2 seconds.
val tripOptions = TripModelOptions.builder().setRefreshIntervalMillis(2000).build()
tripModel.setTripModelOptions(tripOptions)

Przestań udostępniać trasę

Pamiętaj, aby zatrzymać udostępnianie ścieżek, gdy nie jest już potrzebne, na przykład w przypadku zniszczenia aktywności hosta. Zatrzymanie udostępniania ścieżek powoduje też zatrzymanie żądań sieciowych wysyłanych do Fleet Engine i zapobiega wyciekom pamięci.

Ten przykładowy kod pokazuje, jak zatrzymać udostępnianie przebiegu.

Java

public class MainActivity extends AppCompatActivity
    implements ConsumerViewModel.JourneySharingListener  {

  // Class implementation

  @Override
  protected void onDestroy() {
    super.onDestroy();

    if (journeySharingSession != null) {
      journeySharingSession.stop();
    }
  }
}

Kotlin

class SampleAppActivity : AppCompatActivity(), ConsumerViewModel.JourneySharingListener {

  // Class implementation

  override fun onDestroy() {
    super.onDestroy()

    journeySharingSession?.stop()
  }
}

Obsługa błędów związanych z podróżą

Metoda onTripRefreshError wyświetla błędy, które występują podczas monitorowania podróży. Mapowanie pakietu SDK klienta są zgodne z wytycznymi HTTP/RPC co Google Cloud Platform Typowe błędy wykrywane podczas monitorowania podróży to między innymi:

HTTP RPC Opis
400 INVALID_ARGUMENT Klient podał nieprawidłową nazwę podróży. nazwa podróży musi mieć format providers/{provider_id}/trips/{trip_id} Wartość provider_id musi być identyfikatorem Projekt Cloud należący do dostawcy usług.
401 BEZ UWIERZYTELNIANIA Żądanie nie zostało uwierzytelnione z powodu nieprawidłowy token JWT. Ten błąd wystąpi jeśli token JWT jest podpisany bez podróży identyfikator lub token JWT wygasł.
403 PERMISSION_DENIED Klient nie ma wystarczających uprawnienia. Ten błąd występuje, jeśli token JWT token jest nieprawidłowy, klient nie ma uprawnienia lub interfejs API jest wyłączony dla z projektem klienta. Token JWT może być brakuje lub token jest podpisany podróżą identyfikator, który nie pasuje do żądanego identyfikatora podróży.
429 RESOURCE_EXHAUSTED Limit zasobów wynosi zero lub wynosi częstotliwość przekracza limit.
503 PRODUKT NIEDOSTĘPNY Usługa niedostępna Zwykle serwer spadła.
504 DEADLINE_EXCEEDED Przekroczono termin prośby. Dzięki temu ma miejsce tylko wtedy, gdy rozmówca ustawi termin która jest krótsza niż domyślna metody terminu (tzn. wskazany termin nie tyle, aby serwer przetworzył ), a prośba nie została zrealizowana w wyznaczonym terminie.

Więcej informacji: Obsługa błędów związanych z pakietem SDK klienta