Aralık ayında San Francisco'da düzenlenecek bir sonraki Google Haritalar Platformu Geliştirici Topluluğu Günü'nde bize katılın. Katılmak için hemen başvurun.

Google, içerikleri tercih ettiğiniz dile çevirmek için yapay zeka teknolojisini kullanır. Yapay zeka çevirilerinde hata olabilir.

Wear OS'te Maps API

Android için Haritalar SDK'sını kullanarak doğrudan Google Wear OS cihazlarda çalışan, harita tabanlı bir giyilebilir uygulama oluşturabilirsiniz. Uygulamanızın kullanıcıları, bileklerine bakarak haritadaki konumlarını görebilir. Örneğin, bir rotadaki konumlarını işaretleyebilir, ardından ayrıntılar için yakınlaştırabilir veya uygulamanız tarafından sağlanan bir bilgi penceresini görmek için bir işaretçiye dokunabilirler.

Bu sayfada, Wear cihazlarda kullanılabilen API işlevleri açıklanmakta ve uygulamanızı oluşturmaya başlamanıza yardımcı olacak bilgiler verilmektedir.

Wear OS'i kullanmaya başlama

Android için Haritalar SDK'sı ile giyilebilir uygulama oluşturmak, diğer Android cihazlar için Google Haritalar uygulaması oluşturmakla temelde aynıdır. Aradaki fark, uygulamanın kullanılabilirliğini ve performansını optimize etmek için giyilebilir cihazın daha küçük form faktörüne yönelik tasarımınızdan kaynaklanır.

Proje kurulumu, kitaplık ekleme ve paketleme kolaylıkları sağladığı için Wear OS geliştirme sürecinde Android Studio'nun kullanılması önerilir.

Giyilebilir uygulama tasarlama konusunda genel yardım için Wear OS tasarım yönergelerine bakın. İlk giyilebilir uygulamanızı oluşturma konusunda yardım için giyilebilir uygulama oluşturma kılavuzuna bakın.

Wear OS'te ilk harita uygulamanızı oluşturma

Bu hızlı kılavuzda, Android için Haritalar SDK'sını bildiğiniz, uygulamanızda giyilebilir modül oluşturmak için Wear OS kılavuzlarını takip ettiğiniz ve şimdi giyilebilir modüle harita eklemek istediğiniz varsayılmaktadır.

Wear modülünüz için bağımlılıklar ekleme

Uygulamanızın Wear OS modülünün build.gradle.kts dosyasına aşağıdaki bağımlılıkların dahil edildiğinden emin olun:

dependencies {
    // ...
    // Modern Android projects use version catalogs to manage dependencies.  To include the necessary dependencies,
    // first add the following to your libs.versions.toml file:
    //
    // [versions]
    // playServicesMaps = "20.1.0"
    // wear = "1.4.0"
    // wearable = "2.9.0"
    //
    // [libraries]
    // play-services-maps = { group = "com.google.android.gms", name = "play-services-maps", version.ref = "playServicesMaps" }
    // wear = { group = "androidx.wear", name = "wear", version.ref = "wear" }
    // wearable-compile = { group = "com.google.android.wearable", name = "wearable", version.ref = "wearable" }
    // wearable-support = { group = "com.google.android.support", name = "wearable", version.ref = "wearable" }

    compileOnly(libs.wearable.compile)
    implementation(libs.wearable.support)
    implementation(libs.play.services.maps)

    // This dependency is necessary for ambient mode
    implementation(libs.wear)

    // Android Test Dependencies
    androidTestImplementation(libs.ext.junit)
    androidTestImplementation(libs.espresso.core)
    androidTestImplementation(libs.uiautomator)
    androidTestImplementation(libs.truth)
    androidTestImplementation(libs.junit)
    
    // If your project does not use a version catalog, you can use the following dependencies instead:
    //
    //    compileOnly("com.google.android.wearable:wearable:2.9.0")
    //    implementation("com.google.android.support:wearable:2.9.0")
    //    implementation("com.google.android.gms:play-services-maps:20.1.0")
    //    implementation("androidx.wear:wear:1.4.0")
    //    androidTestImplementation("androidx.test.ext:junit:1.3.0")
    //    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
    //    androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0")
    //    androidTestImplementation("com.google.truth:truth:1.4.5")
    //    androidTestImplementation("junit:junit:4.13.2")
}

Bağımlılıklar hakkında daha fazla bilgi için Mevcut projenize Wear OS modülü ekleme kılavuzuna bakın.

Kaydırarak kapatma hareketini uygulama ve ilk arka plan rengini ayarlama

Haritayı giyilebilir cihazda görüntülemek için SwipeDismissFrameLayout kullanmanız önerilir. SwipeDismissFrameLayout sınıfını kullanarak kaydırarak kapatma hareketini uygulayabilir ve kullanıcılara ekranın en sol kenarından kaydırarak uygulamadan çıkma imkanı sunabilirsiniz.

Özel bir ilk arka plan rengi ayarlamak için map:backgroundColor XML özelliğini kullanarak gerçek harita parçaları yüklenene kadar gösterilecek rengi tanımlayın.

SupportMapFragment öğesinin kapsayıcısı olarak düzen tanımınıza SwipeDismissFrameLayout ve backgroundColor öğelerini ekleyin:

  <androidx.wear.widget.SwipeDismissFrameLayout
      android:id="@+id/map_container"
      android:layout_width="match_parent"
      android:layout_height="match_parent">
    <fragment
        android:id="@+id/map"
        android:name="com.google.android.gms.maps.SupportMapFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        map:backgroundColor="#fff0b2dd" />
  </androidx.wear.widget.SwipeDismissFrameLayout>

Etkinliğinizde SwipeDismissFrameLayout nesnesini aldığınızda bir geri çağırma ekleyin ve geri çağırmanın davranışını, gerekli kapatma işlemini aşağıda gösterildiği gibi gerçekleştirecek şekilde ayarlayın:

Kotlin

class MainActivity :
    AppCompatActivity(),
    OnMapReadyCallback,
    AmbientModeSupport.AmbientCallbackProvider {


    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        try {
            val controller = AmbientModeSupport.attach(this)
            Log.d(MainActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)
        } catch (e: Exception) {
            Log.w(MainActivity::class.java.simpleName, "Ambient mode unavailable on this device: ${e.message}")
        }

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        val mapFrameLayout = findViewById<SwipeDismissFrameLayout>(R.id.map_container)
        mapFrameLayout.addCallback(object : SwipeDismissFrameLayout.Callback() {
            override fun onDismissed(layout: SwipeDismissFrameLayout) {
                onBackPressed()
            }
        })

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    // ...
}

Java

public class MainActivity extends AppCompatActivity
        implements OnMapReadyCallback, AmbientModeSupport.AmbientCallbackProvider {


    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        try {
            AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
            Log.d(
                    MainActivity.class.getSimpleName(),
                    "Is ambient enabled: " + controller.isAmbient());
        } catch (Exception e) {
            Log.w(
                    MainActivity.class.getSimpleName(),
                    "Ambient mode unavailable on this device: " + e.getMessage());
        }

        // Retrieve the containers for the root of the layout and the map. Margins will need to be
        // set on them to account for the system window insets.
        final SwipeDismissFrameLayout mapFrameLayout =
                (SwipeDismissFrameLayout) findViewById(R.id.map_container);
        mapFrameLayout.addCallback(
                new SwipeDismissFrameLayout.Callback() {
                    @Override
                    public void onDismissed(SwipeDismissFrameLayout layout) {
                        onBackPressed();
                    }
                });

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    }

    // ...
}

Harita ekleme

GoogleMap nesnesinin herkese açık bir örneğini almak için her zamanki gibi onMapReady(GoogleMap) geri çağırma yöntemini kullanın. Geri çağırma, harita kullanıma hazır olduğunda tetiklenir. Geri çağırma yönteminde haritaya işaretçi veya çoklu çizgi ekleyebilir, dinleyici ekleyebilir ya da kamerayı hareket ettirebilirsiniz. Aşağıdaki örnekte, Sidney Opera Binası'nın yakınına bir işaretçi eklenmektedir:

Kotlin

private val sydney = LatLng(-33.85704, 151.21522)

override fun onMapReady(googleMap: GoogleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(
        MarkerOptions().position(sydney)
            .title("Sydney Opera House"),
    )

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(sydney, 10f))
}

Java

private static final LatLng SYDNEY = new LatLng(-33.85704, 151.21522);

@Override
public void onMapReady(@NonNull GoogleMap googleMap) {
    // Add a marker with a title that is shown in its info window.
    googleMap.addMarker(new MarkerOptions().position(SYDNEY).title("Sydney Opera House"));

    // Move the camera to show the marker.
    googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(SYDNEY, 10));
}

Ambiyans modunu etkinleştirme

Android için Haritalar SDK'sı, giyilebilir uygulamalar için ambiyans modunu destekler. Ambiyans modunu destekleyen uygulamalar bazen her zaman açık uygulamalar olarak adlandırılır. Ambiyans modu, kullanıcı uygulamayı aktif olarak kullanmayı bıraktığında etkinleştirilir ve uygulamanın giyilebilir cihazda görünür kalmasını sağlar.

Android için Haritalar SDK'sı, ambiyans modunda kullanılmak üzere haritanın basitleştirilmiş, az renkli bir oluşturma işlemini sağlar ve cihaz etkileşimli moddan ambiyans moduna geçtiğinde harita stili otomatik olarak ayarlanır. Ambiyans modunda tüm işaretçiler, nesneler ve kullanıcı arayüzü kontrolleri kaybolur. Bu, uygulamanızın güç tüketimini azaltır ve kadranlar gibi diğer ambiyans uygulamalarıyla tutarlı bir görünüm ve tarz sağlar.

Uygulamanızın haritanın ambiyans modunu kullandığından emin olmak için aşağıdaki adımları uygulayın:

Android SDK'nızı, etkinliklerin ambiyans moduna geçmesini sağlayan API'leri sunan Android 6.0 (API 23) veya sonraki bir platformu içerecek şekilde güncelleyin. SDK'nızı nasıl güncelleyeceğiniz hakkında bilgi edinmek için SDK paketleri ekleme ile ilgili Android belgelerine bakın.
Uygulama manifestinde targetSdkVersion değerini 23 veya daha yüksek bir değere ayarlayarak projenizin Android 6.0 veya sonraki sürümleri hedeflediğinden emin olun.
Giyilebilir cihaz bağımlılıklarını uygulamanızın build.gradle.kts dosyasına ekleyin. Bu sayfadaki örneği inceleyin.
Android eğitim sınıfında uygulamanızı görünür tutma ile ilgili bölümde açıklandığı gibi, giyilebilir paylaşılan kitaplık girişini giyilebilir uygulama manifestine ekleyin.
Uygulamanızı görünür tutma ile ilgili Android eğitim sınıfında açıklandığı gibi, WAKE_LOCK iznini el cihazı ve giyilebilir uygulama manifestlerine ekleyin.
Etkinliğinizin onCreate() yönteminde AmbientModeSupport.attach() yöntemini çağırın. Bu, işletim sistemine uygulamanın her zaman açık olduğunu bildirir. Böylece cihaz kapandığında kadran yerine ambiyans moduna girer.
Ambiyans modu durum değişikliklerini alabilmesi için etkinliğinizde AmbientModeSupport.AmbientCallbackProvider arayüzünü uygulayın.
Haritanızı ambiyans modunu destekleyecek şekilde ayarlayın. Bunu, etkinliğin XML düzen dosyasında map:ambientEnabled="true" özelliğini ayarlayarak veya GoogleMapOptions.ambientEnabled(true) özelliğini ayarlayarak programatik olarak yapabilirsiniz. Bu ayar, API'ye ambiyans modunda kullanılacak gerekli harita parçalarını önceden yüklemesi gerektiğini bildirir.
Etkinlik ambiyans moduna geçtiğinde sistem, sağladığınız AmbientCallback içinde onEnterAmbient() yöntemini çağırır. onEnterAmbient() numarasını geçersiz kıl ve SupportMapFragment.onEnterAmbient(ambientDetails) veya MapView.onEnterAmbient(ambientDetails) numarasını ara. API, haritanın etkileşimli olmayan ve az renkli bir oluşturma biçimine geçer.
Benzer şekilde, onExitAmbient() dilinde SupportMapFragment.onExitAmbient() veya MapView.onExitAmbient() diyebilirsiniz. API, haritanın normal oluşturma moduna geçer.

Aşağıdaki kod örneği, etkinlikte ambiyans modunu etkinleştirir:

Kotlin

class AmbientActivity :
    AppCompatActivity(),
    AmbientModeSupport.AmbientCallbackProvider {

    private lateinit var mapFragment: SupportMapFragment

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main)

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        try {
            val controller = AmbientModeSupport.attach(this)
            Log.d(AmbientActivity::class.java.simpleName, "Is ambient enabled: " + controller.isAmbient)
        } catch (e: Exception) {
            Log.w(AmbientActivity::class.java.simpleName, "Ambient mode unavailable on this device: ${e.message}")
        }

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
    }

    override fun getAmbientCallback(): AmbientModeSupport.AmbientCallback =
        object : AmbientModeSupport.AmbientCallback() {
            /**
             * Starts ambient mode on the map.
             * The API swaps to a non-interactive and low-color rendering of the map when the user is no
             * longer actively using the app.
             */
            override fun onEnterAmbient(ambientDetails: Bundle) {
                super.onEnterAmbient(ambientDetails)
                mapFragment.onEnterAmbient(ambientDetails)
            }

            /**
             * Exits ambient mode on the map.
             * The API swaps to the normal rendering of the map when the user starts actively using the app.
             */
            override fun onExitAmbient() {
                super.onExitAmbient()
                mapFragment.onExitAmbient()
            }
        }
}

Java

public class AmbientActivity extends AppCompatActivity
        implements AmbientModeSupport.AmbientCallbackProvider {

    private SupportMapFragment mapFragment;

    public void onCreate(Bundle savedState) {
        super.onCreate(savedState);

        // Set the layout. It only contains a SupportMapFragment and a DismissOverlay.
        setContentView(R.layout.activity_main);

        // Enable ambient support, so the map remains visible in simplified, low-color display
        // when the user is no longer actively using the app but the app is still visible on the
        // watch face.
        try {
            AmbientModeSupport.AmbientController controller = AmbientModeSupport.attach(this);
            Log.d(
                    AmbientActivity.class.getSimpleName(),
                    "Is ambient enabled: " + controller.isAmbient());
        } catch (Exception e) {
            Log.w(
                    AmbientActivity.class.getSimpleName(),
                    "Ambient mode unavailable on this device: " + e.getMessage());
        }

        // Obtain the MapFragment and set the async listener to be notified when the map is ready.
        mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
    }

    @Override
    public AmbientCallback getAmbientCallback() {
        return new AmbientCallback() {
            /**
             * Starts ambient mode on the map. The API swaps to a non-interactive and low-color
             * rendering of the map when the user is no longer actively using the app.
             */
            @Override
            public void onEnterAmbient(Bundle ambientDetails) {
                super.onEnterAmbient(ambientDetails);
                mapFragment.onEnterAmbient(ambientDetails);
            }

            /**
             * Exits ambient mode on the map. The API swaps to the normal rendering of the map when
             * the user starts actively using the app.
             */
            @Override
            public void onExitAmbient() {
                super.onExitAmbient();
                mapFragment.onExitAmbient();
            }
        };
    }
}

Uygulama ambiyans modundayken ekranı güncelleyebilirsiniz. İçeriği güncelleme ve genel olarak ambiyans modu hakkında daha fazla bilgi için uygulamanızı görünür tutma ile ilgili Android eğitim sınıfına bakın.

Wear OS'te Street View'u kullanma

Street View, giyilebilir cihazlarda tam olarak desteklenir.

Kullanıcıların Street View panoraması görüntülerken uygulamadan çıkmasına izin vermek için StreetViewPanorama.OnStreetViewPanoramaLongClickListener arayüzünü kullanarak uzun tıklama hareketini dinleyin. Kullanıcı Street View görüntüsünde bir yeri uzun süre tıkladığında onStreetViewPanoramaLongClick(StreetViewPanoramaOrientation) etkinliği alırsınız. Çıkış düğmesini görüntülemek için DismissOverlayView.show() yöntemini çağırın.

Örnek kod

GitHub'da, uygulamanız için başlangıç noktası olarak kullanabileceğiniz örnek bir uygulama mevcuttur. Örnekte, Wear OS'te temel bir Google Haritası'nın nasıl ayarlanacağı gösterilmektedir.