<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sümeyra Polat on Medium]]></title>
        <description><![CDATA[Stories by Sümeyra Polat on Medium]]></description>
        <link>https://medium.com/@sumeyrapolat?source=rss-4d07eccbf96b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BXmGuc8i7LYxy6Z8kUdY3A.jpeg</url>
            <title>Stories by Sümeyra Polat on Medium</title>
            <link>https://medium.com/@sumeyrapolat?source=rss-4d07eccbf96b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 08:30:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sumeyrapolat/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Kotlin ile Android Geliştirmede @Serializable Anotasyonunun Önemi]]></title>
            <link>https://medium.com/huawei-developers-tr/kotlin-ile-android-geli%C5%9Ftirmede-serializable-anotasyonunun-%C3%B6nemi-ee703f2bc2e1?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee703f2bc2e1</guid>
            <category><![CDATA[türkçe]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[serializable]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Wed, 23 Oct 2024 13:19:57 GMT</pubDate>
            <atom:updated>2024-10-23T13:27:04.505Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*nqdsxUIsDV36vlU8cnwhEw.png" /><figcaption><a href="https://blog.hostingdunyam.com.tr/kotlin-nedir/">Referans Resim</a></figcaption></figure><h4><strong>Giriş</strong></h4><p>Günümüzde mobil uygulamalar, kullanıcılarla etkileşim kurmak ve veri alışverişi yapmak için sıklıkla uzak sunucularla iletişim kurmaktadır. Bu iletişimin en yaygın yöntemi API’ler aracılığıyla veri çekmektir. Özellikle Android uygulama geliştirme dünyasında, Kotlin programlama dili ve JSON formatı bu veri alışverişinin temel yapı taşlarıdır. Uygulamanın işleyişini sağlamak için, JSON verilerinin Kotlin sınıflarına doğru şekilde çevrilmesi (deserileştirme) ve Kotlin verilerinin JSON formatına dönüştürülmesi (serileştirme) gerekir. İşte bu noktada, Kotlin’de veri modellemesi için kullanılan @Serializable anotasyonu devreye girer. Bu yazıda, bu anotasyonun kullanım alanlarını ve özellikle uygulamanızın release sürümlerinde karşılaşabileceğiniz olası zorlukları ele alacağız.</p><p>@Serializable, Kotlinx Serialization kütüphanesinde kullanılan bir anotasyondur. Bu anotasyon, bir sınıfın serileştirilebilir ve deserileştirilebilir olmasını sağlayan bilgiyi sunar. API’den çekilen JSON verilerini Kotlin nesnelerine dönüştürmek için serileştirme ve deserileştirme işlemlerini kullanırız. @Serializable anotasyonu, bu işlemler için Kotlin sınıflarının uygun hale gelmesini sağlar.</p><pre>import kotlinx.serialization.Serializable<br><br>@Serializable<br>data class User(val id: Int, val name: String)</pre><p>Yukarıdaki örnekte, User sınıfı JSON formatında serileştirilebilir ve deserileştirilebilir hale gelmiştir.</p><h4>Orta Seviye: @Serializable Kullanılmadığında Karşılaşılabilecek Zorluklar</h4><p>Eğer @Serializable anotasyonunu kullanmazsanız, Kotlin sınıfınız serileştirme ve deserileştirme işlemleri için uygun olmaz ve bu işlemler sırasında hatalar alırsınız. Bu durum, veri alışverişinin güvenilir bir şekilde gerçekleşmemesine yol açabilir.</p><h4>İleri Seviye: Gelişmiş Kullanım ve Özelleştirmeler</h4><ul><li><strong>Alan Adı Özelleştirme</strong>: API’den gelen JSON verilerinin alan adları, Kotlin sınıfınızdaki alan adlarıyla birebir uyuşmayabilir. Bu durumda, @SerialName anotasyonunu kullanarak JSON’daki alan adlarını Kotlin sınıfınızla eşleştirebilirsiniz.</li></ul><pre>@Serializable<br>data class User(<br>    @SerialName(&quot;user_id&quot;) val id: Int,<br>    @SerialName(&quot;user_name&quot;) val name: String<br>)</pre><ul><li><strong>Varsayılan Değerler</strong>: Kotlin sınıflarınıza varsayılan değerler tanımlayarak serileştirme ve deserileştirme işlemlerinde esneklik sağlayabilirsiniz.</li></ul><pre>@Serializable<br>data class User(<br>    val id: Int = 0,<br>    val name: String = &quot;Unknown&quot;<br>)</pre><ul><li><strong>Özel Serileştiriciler</strong>: Eğer standart serileştirme yeterli değilse, özel serileştiriciler tanımlayabilirsiniz.</li></ul><pre>@Serializable(with = CustomDateSerializer::class)<br>data class Event(val date: Date)</pre><h4>Release Aşamasında Yaşanabilecek Sorunlar</h4><p>Genellikle temel seviye Android eğitimlerinde, API’den gelen JSON verilerinin alan adlarının Kotlin sınıfındaki alan adlarıyla birebir uyuşması gerektiği öğretilir. Ancak uygulamanın release aşamasında bu yaklaşım bazı sorunlara yol açabilir. Bunun nedeni, Proguard ve benzeri araçların kullanılmasıdır.</p><p><strong>Proguard ve Alan Adı Karışıklığı</strong>: Proguard, uygulamanızın boyutunu küçültmek ve kodunuzu optimize etmek için kullanılan bir araçtır. Aynı zamanda kodunuzu tersine mühendislikten korumak için de işlev görür. Proguard, sınıf adlarını, metod adlarını ve değişken adlarını küçültür ve karmaşık hale getirir. Bu durum, JSON verisindeki alan adlarıyla Kotlin sınıfınızdaki alan adlarının uyuşmadığında veri uyuşmazlıklarına ve uygulamanızın düzgün çalışmamasına neden olabilir.</p><h4>Çözüm</h4><p>Proguard’ın belirli sınıfları ve alan adlarını karıştırmamasını sağlamak için kurallar tanımlayabilirsiniz. Bu kurallar, belirli sınıflar ve alan adlarını koruma altına alır ve değiştirilmez.</p><pre>-keep class com.example.yourapp.models.** { *; }</pre><p>Ancak, Proguard kuralları tanımlansa bile, @Serializable ve @SerialName anotasyonlarını kullanmak en güvenilir yöntemdir. Bu anotasyonlar, JSON alan adları ile Kotlin sınıfı alan adları arasında belirgin bir eşleştirme yapılmasını sağlar ve Proguard bu eşleştirmeyi bozmaz.</p><pre>import kotlinx.serialization.Serializable<br>import kotlinx.serialization.SerialName<br><br>@Serializable<br>data class User(<br>    @SerialName(&quot;user_id&quot;) val id: Int,<br>    @SerialName(&quot;user_name&quot;) val name: String<br>)</pre><h4>Sonuç</h4><p>API’den gelen verilerdeki alan adlarını Kotlin sınıflarında birebir kullanmak, temel seviyede yeterli olabilir. Ancak uygulamanız release aşamasına geldiğinde Proguard gibi araçlar nedeniyle bu yöntem sorun yaratabilir. Bu nedenle, @Serializable ve @SerialName anotasyonlarını kullanarak alan adlarını açıkça tanımlamak ve gerekli Proguard kurallarını belirlemek en iyi uygulamadır. Bu sayede veri uyuşmazlıklarını önleyebilir ve uygulamanızın kararlı bir şekilde çalışmasını sağlayabilirsiniz.</p><p>Bu yazıda, Kotlin ile Android geliştirmede @Serializable anotasyonunun önemini ve kullanılmaması durumunda yaşanacak zorlukları ele aldık. Uygulamalarınızın daha güvenilir ve kararlı olmasını sağlamak için bu teknikleri kullanmanızı öneririm.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*nJm5hmIoHLLkehDtDIeTvQ.gif" /><figcaption><a href="https://tenor.com/tr/view/donald-duck-gif-gif-15114629240661328737">Referans Gif</a></figcaption></figure><h4>Referanslar</h4><p>Kotlinx Serialization Resmi Dokümantasyonu:</p><p><a href="https://github.com/Kotlin/kotlinx.serialization">GitHub - Kotlin/kotlinx.serialization: Kotlin multiplatform / multi-format serialization</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee703f2bc2e1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-developers-tr/kotlin-ile-android-geli%C5%9Ftirmede-serializable-anotasyonunun-%C3%B6nemi-ee703f2bc2e1">Kotlin ile Android Geliştirmede @Serializable Anotasyonunun Önemi</a> was originally published in <a href="https://medium.com/huawei-developers-tr">Huawei Developers - Türkiye</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bluetooth ile IoT’yi Android’de Keşfedin: Adım Adım Bağlantı ve İletişim]]></title>
            <link>https://medium.com/@sumeyrapolat/bluetooth-ile-iotyi-android-de-ke%C5%9Ffedin-ad%C4%B1m-ad%C4%B1m-ba%C4%9Flant%C4%B1-ve-i%CC%87leti%C5%9Fim-248ef8a0aa8b?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/248ef8a0aa8b</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Mon, 16 Sep 2024 11:00:38 GMT</pubDate>
            <atom:updated>2024-09-16T11:00:38.873Z</atom:updated>
            <content:encoded><![CDATA[<p>IoT (Nesnelerin İnterneti) cihazları, yaşamımızı daha akıllı ve verimli hale getiren çözümler sunar. Android cihazlarla bu IoT cihazlarını Bluetooth aracılığıyla kontrol etmek, kullanıcıların cihazlara doğrudan erişim sağlamasına olanak tanır. Bu yazıda, Bluetooth LE (Low Energy) ve Classic Bluetooth arasındaki farklar, UUID kullanımı ve her iki türde de bağlantı kurma ve veri okuma yöntemleri gibi temel kavramları inceleyeceğiz. Ayrıca, Bluetooth kullanırken dikkat edilmesi gereken diğer önemli noktaları da ele alacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*PVXzCcnkiXDhWlryXk9q1g.jpeg" /><figcaption>Internet Of Things</figcaption></figure><h3>Bluetooth LE (Low Energy) vs. Classic Bluetooth</h3><ul><li><strong>Bluetooth LE (Low Energy):</strong> Bu protokol, IoT cihazları için düşük enerji tüketimi ile ideal bir çözümdür. Özellikle sensör verilerinin aktarımı gibi düşük veri iletimi gereksinimleri için uygundur ve pil ömrünü uzatır.</li><li><strong>Classic Bluetooth:</strong> Daha yüksek veri aktarım hızına sahiptir ancak daha fazla enerji tüketir. Ses ve medya akışı gibi yüksek veri iletimi gerektiren uygulamalar için tercih edilir.</li></ul><h3>UUID (Universal Unique Identifier)</h3><p>Bluetooth ile cihazlar arasında bağlantı kurarken, her cihaz veya hizmetin benzersiz olarak tanımlanması için UUID kullanılır.</p><ul><li><strong>Classic Bluetooth:</strong> SPP (Serial Port Profile) gibi belirli bir hizmeti temsil eden bir UUID kullanılır.</li><li><strong>Bluetooth LE:</strong> Cihazın sunduğu özel hizmetler ve özelliklerin tanımlanmasında UUID kullanılır.</li></ul><h3>Classic Bluetooth ile Bağlantı Kurma ve Veri Okuma</h3><p>Classic Bluetooth, medya ve ses iletimi gibi uygulamalar için uygundur. Aşağıda, Classic Bluetooth ile bir cihaza bağlanma ve veri okuma örneği yer almaktadır:</p><pre>import android.bluetooth.BluetoothAdapter<br>import android.bluetooth.BluetoothDevice<br>import android.bluetooth.BluetoothSocket<br>import java.io.IOException<br>import java.io.InputStream<br>import java.util.UUID<br><br>class ClassicBluetoothConnection {<br>    private val deviceAddress = &quot;XX:XX:XX:XX:XX:XX&quot;<br>    private val uuid: UUID = UUID.fromString(&quot;00001101-0000-1000-8000-00805F9B34FB&quot;)<br><br>    private var bluetoothAdapter: BluetoothAdapter? = null<br>    private var bluetoothSocket: BluetoothSocket? = null<br>    private var inputStream: InputStream? = null<br><br>    fun connectToDevice() {<br>        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()<br>        val device: BluetoothDevice = bluetoothAdapter!!.getRemoteDevice(deviceAddress)<br><br>        try {<br>            bluetoothSocket = device.createRfcommSocketToServiceRecord(uuid)<br>            bluetoothSocket!!.connect()<br>            inputStream = bluetoothSocket!!.inputStream<br>        } catch (e: IOException) {<br>            e.printStackTrace()<br>        }<br>    }<br><br>    fun readData(): String {<br>        val buffer = ByteArray(1024)<br>        var bytes: Int<br>        var data = &quot;&quot;<br><br>        try {<br>            bytes = inputStream!!.read(buffer)<br>            data = String(buffer, 0, bytes)<br>        } catch (e: IOException) {<br>            e.printStackTrace()<br>        }<br><br>        return data<br>    }<br><br>    fun closeConnection() {<br>        try {<br>            inputStream?.close()<br>            bluetoothSocket?.close()<br>        } catch (e: IOException) {<br>            e.printStackTrace()<br>        }<br>    }<br>}</pre><p>Bu kod, Classic Bluetooth ile bir cihaza bağlanır ve veri okuma işlemi yapar. BluetoothSocket üzerinden bağlantı kurulur ve veri aktarımı gerçekleştirilir.</p><h3>Bluetooth LE ile Bağlantı Kurma ve Veri Okuma</h3><p>Bluetooth LE, daha düşük enerji tüketimi ile sensör verilerinin aktarımı gibi düşük veri iletimi gereksinimleri için idealdir. Aşağıda, Bluetooth LE ile bağlantı kurma ve veri alışverişi örneği bulunmaktadır:</p><pre>import android.bluetooth.BluetoothAdapter<br>import android.bluetooth.BluetoothDevice<br>import android.bluetooth.BluetoothGatt<br>import android.bluetooth.BluetoothGattCallback<br>import android.content.Context<br><br>class BluetoothLEConnection(private val context: Context) {<br>    private val deviceAddress = &quot;XX:XX:XX:XX:XX:XX&quot;<br>    private var bluetoothAdapter: BluetoothAdapter? = null<br>    private var bluetoothGatt: BluetoothGatt? = null<br><br>    private val gattCallback = object : BluetoothGattCallback() {<br>        // GATT callback metodları burada implement edilir<br>    }<br><br>    fun connectToDevice() {<br>        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()<br>        val device: BluetoothDevice = bluetoothAdapter!!.getRemoteDevice(deviceAddress)<br>        bluetoothGatt = device.connectGatt(context, false, gattCallback)<br>    }<br><br>    fun disconnect() {<br>        bluetoothGatt?.disconnect()<br>        bluetoothGatt?.close()<br>    }<br>}</pre><p>Bu kodda, Bluetooth LE kullanılarak bir cihaza bağlantı kurulur. BluetoothGatt ile bağlantı yapılır ve BluetoothGattCallback ile cihazın özelliklerine ve hizmetlerine erişim sağlanır.</p><h3>BluetoothAdapter, BluetoothSocket ve InputStream Nedir?</h3><h4>BluetoothAdapter</h4><p><strong>Tanım:</strong> BluetoothAdapter, Android cihazının Bluetooth modülüne erişim sağlayan ve Bluetooth işlemlerini yöneten bir sınıftır.</p><p><strong>Görevleri:</strong></p><ul><li><strong>Bluetooth’u Açma/Kapama:</strong> BluetoothAdapter ile cihazın Bluetooth&#39;u açılıp kapatılabilir. Örneğin, bluetoothAdapter.enable() ile Bluetooth açılabilir.</li><li><strong>Cihazları Tarama:</strong> Mevcut Bluetooth cihazlarını taramak ve keşfetmek için kullanılır. startDiscovery() metodu, yakındaki Bluetooth cihazlarını arar.</li><li><strong>Bağlantı Kontrolü:</strong> Cihazın Bluetooth’unun aktif olup olmadığını kontrol edebilir. bluetoothAdapter.isEnabled() ile Bluetooth&#39;un durumu öğrenilebilir.</li><li><strong>Eşleştirilmiş Cihazları Listeleme:</strong> Daha önce eşleştirilmiş cihazların listesini almak için kullanılır. bluetoothAdapter.bondedDevices ile eşleştirilmiş cihazlar listelenir.</li></ul><h4>BluetoothSocket</h4><p><strong>Tanım:</strong> BluetoothSocket, iki Bluetooth cihazı arasında bağlantı kurmak ve veri iletmek için kullanılan bir soket sınıfıdır. TCP/IP soketlerine benzer bir şekilde çalışır ve iki cihaz arasında güvenilir bir iletişim kanalı sağlar.</p><p><strong>Görevleri:</strong></p><ul><li><strong>Bağlantı Kurma:</strong> BluetoothSocket ile hedef cihaza bağlantı kurulur. Bu bağlantı, UUID kullanılarak tanımlanır ve connect() metodu ile başlatılır.</li><li><strong>Veri İletimi:</strong> Bağlantı kurulduktan sonra, BluetoothSocket üzerinden veri gönderilip alınabilir. Bu soket, cihazlar arasında doğrudan iletişim kurmayı sağlar.</li><li><strong>Bağlantıyı Kapatma:</strong> Veri iletimi tamamlandığında, close() metodu kullanılarak bağlantı kapatılır. Bu, kaynak sızıntılarını önler ve uygulamanın verimli çalışmasını sağlar.</li></ul><h4>InputStream</h4><p><strong>Tanım:</strong> InputStream, Java ve Android&#39;de veri okumak için kullanılan bir akış sınıfıdır. BluetoothSocket ile bağlantı kurulduğunda, hedef cihazdan gelen verileri almak için InputStream kullanılır.</p><p><strong>Görevleri:</strong></p><ul><li><strong>Veri Okuma:</strong> InputStream, bağlı cihazdan gelen verileri okur. Bu veriler genellikle bayt dizisi (byte array) formatında gelir ve işlenmek üzere uygulama içerisinde alınır. Örneğin, sensör verileri gibi.</li><li><strong>Veri İşleme:</strong> Okunan veriler, bayt dizisi olarak alındıktan sonra uygun bir formata dönüştürülür (örneğin, String). Bu işlem, verilerin kullanıcı arayüzünde görüntülenmesini veya diğer işlemler için kullanılmasını sağlar.</li><li><strong>Bağlantıyı Kapatma:</strong> Veri okuma işlemi tamamlandığında, inputStream.close() ile akış kapatılır. Bu, kaynakların serbest bırakılmasını ve uygulamanın düzgün çalışmasını sağlar.</li></ul><h4>Özet:</h4><ul><li><strong>BluetoothAdapter:</strong> Cihazdaki Bluetooth donanımını yönetir, Bluetooth’u açar/kapatır, cihazları tarar ve eşleştirilmiş cihazları listeler.</li><li><strong>BluetoothSocket:</strong> İki Bluetooth cihazı arasında bağlantı kurar ve veri iletimi sağlar. Bağlantı kurulumu, UUID ile tanımlanır ve bağlantıyı yönetir.</li><li><strong>InputStream:</strong> Bluetooth üzerinden gelen verileri okumak için kullanılır. Veri akışını alır, işleme hazır hale getirir ve gerektiğinde akışı kapatır.</li></ul><h3>Bluetooth Pairing ve Bonding</h3><ul><li><strong>Pairing:</strong> İki Bluetooth cihazı arasında ilk kez bağlantı kurulduğunda yapılan işlemdir. Güvenli bir bağlantı için bir şifreleme anahtarı paylaşılır.</li><li><strong>Bonding:</strong> Pairing işleminden sonra, cihazların birbirini hatırlamasını ve gelecekteki bağlantılarda daha hızlı eşleşme yapmasını sağlar.</li></ul><h3>Bluetooth Profiles</h3><p>Bluetooth, belirli kullanım durumlarına uygun hale getirilmesi için profiller içerir. Örneğin:</p><ul><li><strong>SPP (Serial Port Profile):</strong> Bluetooth üzerinden seri veri iletimi sağlar ve IoT cihazlarıyla veri alışverişi yapmak için yaygın olarak kullanılır.</li></ul><h3>Bluetooth Permissions</h3><p>Android uygulamalarının Bluetooth işlevlerini kullanabilmesi için belirli izinler gereklidir. Örneğin:</p><ul><li>BLUETOOTH</li><li>BLUETOOTH_ADMIN</li><li>ACCESS_FINE_LOCATION</li></ul><p>Bu izinler, cihazları taramak ve bağlantı kurmak için gereklidir.</p><h3>Veri İşleme ve Yönetimi</h3><p>Bluetooth üzerinden alınan veriler genellikle bayt dizisi (byte array) formatında gelir. Bu verilerin doğru bir şekilde işlenip anlamlandırılması önemlidir. Örneğin, sensör verilerini doğru birimlere çevirmek, uygulamanın doğru çalışabilmesi için kritiktir.</p><h3>Hata Yönetimi ve Bağlantı Kontrolü</h3><p>Bluetooth bağlantıları her zaman kararlı olmayabilir, bu nedenle hata işleme ve bağlantı yönetimi önemlidir. Örneğin, bağlantı kesilmesi veya veri aktarım hataları gibi durumları doğru şekilde ele almak gerekir.</p><h3>Çoklu İş Parçacığı ve Asenkron Operasyonlar</h3><p>Bluetooth iletişimi zaman alıcı olabilir. Uzun süreli işlemler, ana kullanıcı arayüzü iş parçacığından bağımsız olarak gerçekleştirilmelidir. Bu, uygulamanın donmasını önler ve kullanıcı deneyimini iyileştirir. AsyncTask, Coroutine, veya Handler gibi yapılar bu amaçla kullanılabilir.</p><h3>Sonuç</h3><p>Android ile IoT cihazlarına Bluetooth üzerinden bağlanmak, kullanıcıların bu cihazları doğrudan mobil cihazlarından kontrol etmelerine ve izlemelerine olanak tanır. Bu süreci etkili bir şekilde gerçekleştirmek için Bluetooth LE, Classic Bluetooth, UUID, pairing, ve bonding gibi kavramların yanı sıra Android’in Bluetooth API’si ile ilgili bilgi sahibi olmak önemlidir. Bu temel bilgileri kullanarak, kendi IoT uygulamanızı geliştirip cihazlarınızla etkili bir şekilde iletişim kurabilirsiniz.</p><p>Eğer daha fazla ayrıntıya ihtiyacınız varsa, şu kaynakları inceleyebilirsiniz:</p><ul><li><a href="https://developer.android.com/guide/topics/connectivity/bluetooth">Android Developers Bluetooth</a> — Android’in resmi dokümantasyonu, Bluetooth bağlantıları hakkında kapsamlı bilgi sağlar.</li><li><a href="https://developer.android.com/samples/">Android Bluetooth API Demos and Tutorials</a> — Android’in Bluetooth API’sini kullanma konusunda pratik örnekler ve rehberler sunar.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=248ef8a0aa8b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin ile Paralel Programlama: Thread, Dispatcher, I/O ve Main Kavramları]]></title>
            <link>https://medium.com/@sumeyrapolat/kotlin-ile-paralel-programlama-thread-dispatcher-i-o-ve-main-kavramlar%C4%B1-687aa1d623ab?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/687aa1d623ab</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Wed, 10 Jul 2024 09:22:31 GMT</pubDate>
            <atom:updated>2024-07-10T09:22:31.965Z</atom:updated>
            <content:encoded><![CDATA[<p>Kotlin, modern uygulamalarda performansı artırmak ve kullanıcı deneyimini iyileştirmek için kullanılan güçlü araçlardan biridir. Özellikle eşzamanlı ve paralel programlama konularında Kotlin Coroutines ile sağlanan esneklik ve kolaylık, geliştiricilerin işini oldukça kolaylaştırır. Bu yazıda, Kotlin’de thread, dispatcher, I/O ve main kavramlarını teknik detaylarla birlikte ele alacağız. Ayrıca, gerçek dünya uygulamalarında nasıl kullanıldıklarına dair örnekler vereceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*d1k4iU3WUkSkdTmp5un6YQ.jpeg" /></figure><h3>1. Thread</h3><p>Thread, bir programın en küçük çalışma birimidir ve eşzamanlı işlemler gerçekleştirilmesini sağlar. Kotlin’de thread’ler, paralel işlemler yapmak için kullanılır, ancak manuel thread yönetimi zordur ve dikkat gerektirir.</p><p><strong>Kotlin’de Thread Kullanımı:</strong></p><pre>fun main() {<br>    val thread = Thread {<br>        println(&quot;Thread çalışıyor&quot;)<br>    }<br>    thread.start()<br>    thread.join()<br>    println(&quot;Main thread bitiyor&quot;)<br>}</pre><p>Bu örnekte, yeni bir thread oluşturulup başlatılmakta ve ana thread’in bu yeni thread’in bitmesini beklemesi sağlanmaktadır.</p><h3>2. Dispatcher</h3><p>Dispatchers, Kotlin Coroutines ile hangi thread’in kullanılacağını belirleyen yapılardır. Coroutine’lerin belirli bir thread’de veya thread havuzunda çalıştırılmasını sağlarlar. Farklı dispatcher türleri vardır:</p><ul><li><strong>Dispatchers.Main</strong>: Ana thread üzerinde çalışır, genellikle UI güncellemeleri için kullanılır.</li><li><strong>Dispatchers.IO</strong>: I/O işlemleri için optimize edilmiştir, disk veya ağ işlemleri gibi.</li><li><strong>Dispatchers.Default</strong>: CPU yoğunluklu işlemler için optimize edilmiştir.</li></ul><p><strong>Kotlin’de Dispatcher Kullanımı:</strong></p><pre>import kotlinx.coroutines.*<br><br>fun main() = runBlocking {<br>    launch(Dispatchers.Default) {<br>        println(&quot;Default dispatcher: ${Thread.currentThread().name}&quot;)<br>    }<br>    launch(Dispatchers.IO) {<br>        println(&quot;IO dispatcher: ${Thread.currentThread().name}&quot;)<br>    }<br>    launch(Dispatchers.Main) {<br>        println(&quot;Main dispatcher: ${Thread.currentThread().name}&quot;)<br>    }<br>}</pre><p>Bu örnekte, farklı dispatcher’lar kullanılarak coroutine’lerin hangi thread’de çalışacağı belirlenmiştir.</p><h3>3. I/O (Input/Output)</h3><p>I/O işlemleri, veri giriş ve çıkış işlemlerini ifade eder. Bu işlemler genellikle uzun sürebilir ve ana thread’in bloklanmasını önlemek için arka planda yapılır.</p><p><strong>Kotlin’de I/O İşlemleri:</strong></p><pre>import kotlinx.coroutines.*<br><br>fun main() = runBlocking {<br>    launch(Dispatchers.IO) {<br>        val data = fetchDataFromNetwork()<br>        println(&quot;Data fetched: $data&quot;)<br>    }<br>}<br><br>suspend fun fetchDataFromNetwork(): String {<br>    delay(2000)<br>    return &quot;Network data&quot;<br>}</pre><p>Bu örnekte, ağdan veri çekme işlemi I/O dispatcher kullanılarak arka planda yapılmıştır.</p><h4><strong>Gerçek Dünya Örneği: Firebase ile I/O İşlemleri</strong></h4><p>Firebase, mobil ve web uygulamaları için yaygın olarak kullanılan bir backend servistir. Firebase ile veri okuma/yazma işlemleri, uzun sürebilecek I/O işlemleridir ve bu işlemler Dispatchers.IO kullanılarak arka planda yapılmalıdır.</p><p><strong>Firebase Kullanarak I/O İşlemleri:</strong></p><pre>import com.google.firebase.firestore.FirebaseFirestore<br>import kotlinx.coroutines.*<br><br>fun main() = runBlocking {<br>    launch(Dispatchers.IO) {<br>        val userData = fetchUserData(&quot;user123&quot;)<br>        println(&quot;User data: $userData&quot;)<br>    }<br>}<br><br>suspend fun fetchUserData(userId: String): String {<br>    return withContext(Dispatchers.IO) {<br>        val firestore = FirebaseFirestore.getInstance()<br>        val document = firestore.collection(&quot;users&quot;).document(userId).get().await()<br>        document.data.toString()<br>    }<br>}</pre><p>Bu örnekte, Firebase Firestore’dan kullanıcı verisi okunmakta ve bu işlem I/O dispatcher kullanılarak arka planda gerçekleştirilmektedir. withContext(Dispatchers.IO) kullanımı, veri okuma işleminin ana thread&#39;i bloklamadan yapılmasını sağlar.</p><h3>4. Main Thread</h3><p>Ana thread, uygulamanın başlangıç thread’idir ve genellikle UI işlemleri burada yapılır. Uzun süren işlemler ana thread’de yapılmamalıdır, aksi takdirde kullanıcı arayüzü donabilir.</p><p><strong>Kotlin’de Main Thread Kullanımı:</strong></p><pre>import kotlinx.coroutines.*<br><br>fun main() = runBlocking(Dispatchers.Main) {<br>    println(&quot;Main thread: ${Thread.currentThread().name}&quot;)<br>    <br>    val result = withContext(Dispatchers.IO) {<br>        fetchDataFromNetwork()<br>    }<br>    <br>    println(&quot;Data: $result&quot;)<br>}</pre><p>Bu örnekte, ağdan veri çekme işlemi I/O dispatcher kullanılarak arka planda yapılmakta ve sonuç ana thread’de işlenmektedir.</p><h4><strong>Gerçek Dünya Örneği: Ana Thread’de UI Güncellemeleri</strong></h4><p>Android uygulamalarında, kullanıcı arayüzünü güncellemek ana thread’de yapılmalıdır.</p><p><strong>Firebase ile Ana Thread’de UI Güncellemesi:</strong></p><pre>import android.os.Bundle<br>import androidx.activity.ComponentActivity<br>import androidx.activity.compose.setContent<br>import androidx.compose.material.*<br>import androidx.compose.runtime.*<br>import com.google.firebase.firestore.FirebaseFirestore<br>import kotlinx.coroutines.*<br><br>class MainActivity : ComponentActivity() {<br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        setContent {<br>            FirebaseUserDataScreen(userId = &quot;user123&quot;)<br>        }<br>    }<br>}<br><br>@Composable<br>fun FirebaseUserDataScreen(userId: String) {<br>    var userData by remember { mutableStateOf(&quot;Loading...&quot;) }<br><br>    // LaunchedEffect is used to run suspend functions in the main thread<br>    LaunchedEffect(userId) {<br>        userData = fetchUserData(userId)<br>    }<br><br>    // The UI is updated on the main thread<br>    Surface(color = MaterialTheme.colors.background) {<br>        Text(text = userData)<br>    }<br>}<br><br>// suspend function that fetches user data from Firebase Firestore<br>suspend fun fetchUserData(userId: String): String {<br>    return withContext(Dispatchers.IO) {<br>        val firestore = FirebaseFirestore.getInstance()<br>        val document = firestore.collection(&quot;users&quot;).document(userId).get().await()<br>        document.data.toString()<br>    }<br>}</pre><p><strong>Ana Thread Kullanımı:</strong></p><ul><li>setContent fonksiyonu, Jetpack Compose ile UI&#39;ı başlatır ve MainActivity içindeki tüm işlemler varsayılan olarak ana thread üzerinde çalışır.</li><li>LaunchedEffect bloğu, Composable fonksiyonun yaşam döngüsü boyunca yalnızca bir kez tetiklenir ve coroutine başlatır. Bu coroutine, fetchUserData fonksiyonunu çağırarak veri çeker.</li><li>LaunchedEffect blokları ve bu bloklar içindeki kodlar, ana thread üzerinde çalışır. Bu sayede UI güncellemeleri ana thread üzerinde gerçekleştirilir.</li></ul><p><strong>Arka Plan İşlemleri:</strong></p><p>fetchUserData fonksiyonu, Firebase Firestore&#39;dan veri çekmek için withContext(Dispatchers.IO) kullanır. Bu sayede, veri çekme işlemi I/O dispatcher ile arka planda gerçekleştirilir ve ana thread bloklanmaz.</p><p><strong>UI Güncellemeleri:</strong></p><p>Surface ve Text bileşenleri, userData değişkeni güncellendiğinde yeniden çizilir. Bu güncellemeler ana thread üzerinde yapılır ve bu sayede kullanıcı arayüzü hızlı ve düzgün bir şekilde güncellenir.</p><p>Bu yapı, Jetpack Compose ile modern Android geliştirme tekniklerini kullanarak kullanıcı arayüzünü ve veri yönetimini optimize eder. Ana thread üzerinde UI güncellemelerini yönetirken, uzun süren işlemleri arka planda gerçekleştiririz.</p><h3>Sonuç</h3><p>Kotlin Coroutines, modern uygulamalarda performansı artırmak ve kullanıcı deneyimini iyileştirmek için güçlü bir araçtır. Coroutine’ler ve dispatchers ile işlemleri uygun thread’lerde çalıştırabilir ve ana thread’in bloklanmasını önleyebilirsiniz. Gerçek dünya uygulamalarında, özellikle Firebase gibi servislerle veri okuma/yazma işlemleri yaparken, I/O dispatcher kullanarak bu işlemleri arka planda gerçekleştirmeniz önemlidir. Ana thread’de ise kullanıcı arayüzü güncellemeleri gibi işlemler yapılmalıdır.</p><p>Daha fazla bilgi ve teknik detaylar için şu kaynaklara göz atabilirsiniz:</p><ul><li><a href="https://developer.android.com/kotlin/coroutines">Android Developers</a></li><li>Baeldung on Kotlin</li><li><a href="https://kotlinlang.org/docs/coroutine-context-and-dispatchers.html">Kotlin Documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=687aa1d623ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose ile Android Hilt Kullanımı]]></title>
            <link>https://medium.com/@sumeyrapolat/jetpack-compose-ile-android-hilt-kullan%C4%B1m%C4%B1-6619b4806cbf?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6619b4806cbf</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Tue, 14 May 2024 21:08:29 GMT</pubDate>
            <atom:updated>2024-05-14T21:08:29.990Z</atom:updated>
            <content:encoded><![CDATA[<p>Merhaba! Bugün Jetpack Compose ile Hilt kullanarak nasıl bağımlılık enjeksiyonu yapabileceğimizi öğreneceğiz. Hilt, Dagger tabanlı bir bağımlılık enjeksiyonu kütüphanesidir ve Jetpack Compose ile sorunsuz bir şekilde entegre edilebilir.</p><h3>Hilt Nedir ve Neden Kullanmalıyız?</h3><p>Hilt, Android uygulamalarında bağımlılık enjeksiyonu işlemlerini basitleştirir. Hilt, Dagger’ın tüm özelliklerini içerirken, Android’e özgü kolaylıklar sunar. Bu sayede kodunuz daha modüler ve test edilebilir hale gelir.</p><h3>Hilt Kurulumu</h3><h3>Adım 1: Gradle Dosyalarını Güncelleme</h3><p>Öncelikle, projenizin build.gradle dosyalarını güncellemeniz gerekecek. Proje seviyesindeki build.gradle dosyasına Hilt için gerekli bağımlılıkları ekleyin: (Bu kısımda en güncel bilgiler için <a href="https://developer.android.com/training/dependency-injection/hilt-android">tıklayınız</a>)</p><pre>buildscript {<br>    ...<br>    dependencies {<br>        ...<br>        classpath &#39;com.google.dagger:hilt-android-gradle-plugin:2.XX.X&#39;<br>    }<br>}</pre><p>Uygulama seviyesindeki build.gradle dosyasına ise şu bağımlılıkları ekleyin:</p><pre>plugins {<br>    id &#39;com.android.application&#39;<br>    id &#39;kotlin-android&#39;<br>    id &#39;kotlin-kapt&#39;<br>    id &#39;dagger.hilt.android.plugin&#39;<br>}<br><br>dependencies {<br>    implementation &quot;com.google.dagger:hilt-android:2.XX.X&quot;<br>    kapt &quot;com.google.dagger:hilt-compiler:2.XX.X&quot;<br>    implementation &quot;androidx.hilt:hilt-navigation-compose:1.0.0&quot;<br>}</pre><h3>Adım 2: Hilt’i Uygulamaya Entegre Etme</h3><p>Application sınıfınızı Hilt ile başlatmak için sınıfınızı @HiltAndroidApp ile işaretleyin:</p><pre>@HiltAndroidApp<br>class MyApplication : Application() {<br>}</pre><h3>Adım 3: Bağımlılıkları Enjekte Etme</h3><p>Artık Hilt’i kullanarak bağımlılıkları enjekte edebilirsiniz. Örneğin, bir Repository sınıfını ViewModel&#39;a enjekte edelim:</p><pre>class MyRepository @Inject constructor() {<br>    // Repository kodları<br>}<br><br>@HiltViewModel<br>class MyViewModel @Inject constructor(<br>    private val repository: MyRepository<br>) : ViewModel() {<br>    // ViewModel kodları<br>}</pre><h3>Adım 4: Compose’da Hilt Entegrasyonu</h3><p>Compose ile birlikte Hilt’i kullanmak için @AndroidEntryPoint anotasyonunu kullanarak Hilt&#39;in Compose işlevselliğini ekleyebiliriz. İşte basit bir örnek:</p><pre>@AndroidEntryPoint<br>class MainActivity : ComponentActivity() {<br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        setContent {<br>            MyApp()<br>        }<br>    }<br>}<br><br>@Composable<br>fun MyApp() {<br>    // Hilt ViewModel&#39;i enjekte ediyoruz<br>    val viewModel: MyViewModel = hiltViewModel()<br>    MyScreen(viewModel)<br>}<br><br>@Composable<br>fun MyScreen(viewModel: MyViewModel) {<br>    // ViewModel&#39;in fonksiyonlarını kullanarak UI oluşturma<br>    val data = viewModel.someLiveData.observeAsState()<br>    Text(text = data.value ?: &quot;Loading...&quot;)<br>}</pre><p>Bu örnekte MainActivity, @AndroidEntryPoint ile işaretlenmiştir ve MyApp composable fonksiyonu içinde Hilt ViewModel&#39;i hiltViewModel() fonksiyonu ile enjekte ediyoruz. Daha sonra MyScreen composable fonksiyonuna ViewModel&#39;i geçiriyoruz ve ViewModel&#39;in sağladığı verileri kullanarak UI oluşturuyoruz.</p><h3>Sonuç</h3><p>Jetpack Compose ile Hilt kullanarak bağımlılık enjeksiyonu yapmak oldukça basittir. Hilt, bağımlılıkları yönetmenizi ve enjekte etmenizi kolaylaştırırken, Compose ise modern ve reaktif bir UI oluşturma süreci sunar. Umarım bu rehber, Compose projelerinizde Hilt’i kullanmaya başlamanıza yardımcı olmuştur. Sorularınızı ve yorumlarınızı mail ile paylaşabilirsiniz. İyi kodlamalar!</p><p>Kaynak: <a href="https://developer.android.com/training/dependency-injection/hilt-android">https://developer.android.com/training/dependency-injection/hilt-android</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6619b4806cbf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android’de Dependency Injection: Uygulamanızı Daha Esnek ve Test Edilebilir Hale Getirin]]></title>
            <link>https://medium.com/@sumeyrapolat/androidde-dependency-injection-uygulaman%C4%B1z%C4%B1-daha-esnek-ve-test-edilebilir-hale-getirin-2a6f12135718?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2a6f12135718</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Tue, 14 May 2024 10:08:47 GMT</pubDate>
            <atom:updated>2024-05-14T10:09:32.231Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Ofdy0B5BZ_BUFiXkyUZpw.jpeg" /></figure><p>Bağımlılık enjeksiyonu (Dependency Injection, DI), programlamada yaygın olarak kullanılan ve Android geliştirmeye oldukça uygun bir tekniktir. DI prensiplerini takip ederek, iyi bir uygulama mimarisi için temel atmış olursunuz. Bağımlılık enjeksiyonunu uygulamak size şu avantajları sağlar:</p><ul><li>Kodun yeniden kullanılabilirliği</li><li>Refaktörün kolaylığı</li><li>Test etmenin kolaylığı</li></ul><h4>Bağımlılık Enjeksiyonunun Temelleri</h4><p>Android’de bağımlılık enjeksiyonuna geçmeden önce, genel olarak bağımlılık enjeksiyonunun nasıl çalıştığını anlamak önemlidir.</p><h4>Bağımlılık Enjeksiyonu Nedir?</h4><p>Sınıflar genellikle diğer sınıflara referanslar gerektirir. Örneğin, bir Car sınıfı, bir Engine sınıfına referans ihtiyaç duyabilir. Bu gereksinim duyulan sınıflara bağımlılık denir ve bu örnekte Car sınıfının, Engine sınıfına sahip olması gerekmektedir.</p><p>Bir sınıfın ihtiyaç duyduğu bir nesneyi elde etmesinin üç yolu vardır:</p><ol><li>Sınıf, ihtiyaç duyduğu bağımlılığı kendisi oluşturur. Yukarıdaki örnekte, Car kendi Engine örneğini oluşturur ve başlatır.</li><li>Bir yerden alır. Bazı Android API’leri, Context getters ve getSystemService() gibi bu şekilde çalışır.</li><li>Bir parametre olarak sağlanır. Uygulama, bu bağımlılıkları sınıf oluşturulurken sağlar veya her bir bağımlılığı gerektiren fonksiyonlara geçirir. Yukarıdaki örnekte, Car yapıcısı, bir Engine parametresi alır.</li></ol><p>Üçüncü seçenek bağımlılık enjeksiyonudur! Bu yaklaşımda, bir sınıfın bağımlılıklarını almasını sağlamak yerine, bu bağımlılıkları sağlarsınız.</p><h4>Bağımlılık Enjeksiyonunun Kodla Gösterimi</h4><p>Bağımlılık enjeksiyonu olmadan, kendi Engine bağımlılığını oluşturan bir Car örneği şöyle görünür:</p><pre>class Car {<br>    private val engine = Engine()<br><br>    fun start() {<br>        engine.start()<br>    }<br>}<br><br>fun main(args: Array&lt;String&gt;) {<br>    val car = Car()<br>    car.start()<br>}</pre><p>Bu, bağımlılık enjeksiyonu örneği değildir çünkü Car sınıfı kendi Engine’ini oluşturur. Bu problemli olabilir çünkü:</p><ul><li>Car ve Engine sıkı sıkıya bağlıdır — bir Car örneği sadece bir tür Engine kullanır ve alternatif uygulamalar veya alt sınıflar kolayca kullanılamaz.</li><li>Engine bağımlılığı test etmeyi zorlaştırır. Car, gerçek bir Engine örneği kullanır, bu da farklı test senaryoları için test doubles kullanmayı engeller.</li></ul><p>Bağımlılık enjeksiyonu ile kod şu şekilde görünür:</p><pre>class Car(private val engine: Engine) {<br>    fun start() {<br>        engine.start()<br>    }<br>}<br><br>fun main(args: Array&lt;String&gt;) {<br>    val engine = Engine()<br>    val car = Car(engine)<br>    car.start()<br>}</pre><p>Bu yaklaşımın avantajları:</p><ul><li>Car’ın yeniden kullanılabilirliği: Car’a farklı Engine uygulamaları geçebilirsiniz. Örneğin, ElectricEngine adlı yeni bir Engine alt sınıfı tanımlayabilirsiniz. DI kullanarak, sadece bu yeni ElectricEngine alt sınıfının bir örneğini Car’a geçmeniz yeterli olur ve Car başka bir değişiklik yapmadan çalışır.</li><li>Car’ın kolay test edilebilirliği: Farklı senaryoları test etmek için test doubles kullanabilirsiniz. Örneğin, FakeEngine adlı bir test double oluşturup farklı testler için yapılandırabilirsiniz.</li></ul><h4>Android’de Bağımlılık Enjeksiyonu Yöntemleri</h4><ol><li>Yapıcı Enjeksiyonu (Constructor Injection): Yukarıda açıklanan yöntemdir. Sınıfın bağımlılıklarını yapıcısına geçirirsiniz.</li><li>Alan Enjeksiyonu (Field Injection): Bazı Android framework sınıfları, sistem tarafından başlatıldığından yapıcı enjeksiyonu mümkün değildir. Alan enjeksiyonu ile sınıf oluşturulduktan sonra bağımlılıklar enjekte edilir.</li></ol><pre>class Car {<br>    lateinit var engine: Engine<br><br>    fun start() {<br>        engine.start()<br>    }<br>}<br><br>fun main(args: Array&lt;String&gt;) {<br>    val car = Car()<br>    car.engine = Engine()<br>    car.start()<br>}</pre><h4>Otomatik Bağımlılık Enjeksiyonu</h4><p>Önceki örnekte, bağımlılıkları el ile yarattınız, sağladınız ve yönettiniz. Bu, manuel bağımlılık enjeksiyonu olarak adlandırılır. Ancak büyük uygulamalarda manuel enjeksiyon zor ve zahmetlidir. Bağımlılıkları doğru bir şekilde birleştirmek büyük miktarda tekrarlayan kod gerektirebilir.</p><p>Bu sorunu çözmek için bağımlılıkları oluşturma ve sağlama sürecini otomatikleştiren kütüphaneler vardır. Bunlar iki kategoriye ayrılır:</p><ul><li>Yansıma (reflection) tabanlı çözümler: Bağımlılıkları çalışma zamanında bağlar.</li><li>Statik çözümler: Bağımlılıkları bağlamak için kodu derleme zamanında oluşturur.</li></ul><h4>Dagger Nedir?</h4><p>Dagger, Java, Kotlin ve Android için popüler bir bağımlılık enjeksiyonu kütüphanesidir ve Google tarafından bakımı yapılır. Dagger, bağımlılık grafiğini sizin için oluşturur ve yönetir. Tamamen statik ve derleme zamanı bağımlılıkları sağlayarak yansıma tabanlı çözümlerin getirdiği birçok geliştirme ve performans sorununu ortadan kaldırır.</p><h4>Hilt Nedir?</h4><p>Hilt, Android’de bağımlılık enjeksiyonu için Jetpack tarafından önerilen kütüphanedir. Hilt, Dagger’ın üzerine inşa edilmiştir ve DI’yi Android uygulamalarında standart bir şekilde uygulamak için konteynerler sağlar ve yaşam döngülerini otomatik olarak yönetir.</p><h4>Bağımlılık Enjeksiyonunun Faydaları</h4><ul><li>Sınıfların yeniden kullanılabilirliği ve bağımlılıkların gevşek bağlanması: Bir bağımlılığın uygulamalarını değiştirmek daha kolaydır. Kod yeniden kullanılabilirliği artar çünkü sınıflar, bağımlılıkların nasıl oluşturulduğunu kontrol etmez, sadece herhangi bir konfigürasyonla çalışır.</li><li>Refaktörün kolaylığı: Bağımlılıklar, API yüzeyinin doğrulanabilir bir parçası olur, bu nedenle nesne oluşturma sırasında veya derleme zamanında kontrol edilebilirler.</li><li>Test etmenin kolaylığı: Bir sınıf bağımlılıklarını yönetmediğinden, farklı senaryoları test etmek için farklı uygulamalar geçebilirsiniz.</li></ul><p>Bağımlılık enjeksiyonunun avantajlarını tam olarak anlamak için, uygulamanızda manuel olarak denemeniz önerilir.</p><p>Bu bilgilerle Android uygulamalarınızda bağımlılık enjeksiyonunu daha iyi anlayabilir ve uygulayabilirsiniz. Bağımlılık enjeksiyonu, uygulamalarınızı daha modüler, test edilebilir ve bakımını kolay hale getirir.</p><p>Kaynak: <a href="https://developer.android.com/training/dependency-injection">https://developer.android.com/training/dependency-injection</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a6f12135718" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Adapter Class’a Veda: Lazy Column’un Yükselişi]]></title>
            <link>https://medium.com/@sumeyrapolat/adapter-classa-veda-lazy-column-un-y%C3%BCkseli%C5%9Fi-783b56b1bfce?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/783b56b1bfce</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Mon, 06 May 2024 18:18:50 GMT</pubDate>
            <atom:updated>2024-05-06T18:18:50.935Z</atom:updated>
            <content:encoded><![CDATA[<p>Android uygulama geliştirmede, UI bileşenlerinin tanımlanması ve yönetilmesi önemli bir rol oynar. Geleneksel yaklaşımlar, özellikle XML tabanlı RecyclerView tanımlamaları, geliştiricilere bazı zorluklar ve karmaşıklıklar yaşatabilir. Ancak, Jetpack Compose’un yükselişiyle birlikte Lazy Column gibi yeni bileşenler, bu zorlukları azaltmak ve daha etkili bir UI geliştirme deneyimi sunmak için ortaya çıkıyor. Bu yazıda, Lazy Column’un ne olduğunu keşfedecek, XML ile RecyclerView tanımlamanın zorluklarına göz atacak ve son olarak da XML ile RecyclerView ve Lazy Column ile kod örneklerini karşılaştıracağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSmtgcs2nyqgpJsHtUOxcQ.png" /></figure><h4>Lazy Column Nedir?</h4><ul><li>Lazy Column, Jetpack Compose’un bir parçası olarak, dinamik bir liste oluşturmak için kullanılan bir bileşendir.</li><li>Lazy Column, veri öğelerini gerektiğinde oluşturur ve ekranda görüntülendiği sürece bellekte saklar, bu da performansı artırır.</li></ul><h4>XML ile RecyclerView Yazmanın Zorlukları</h4><ul><li>XML tabanlı RecyclerView tanımlamaları, karmaşık XML dosyalarının yönetimini gerektirebilir ve okunabilirliği azaltabilir.</li><li>Adapter sınıfının tanımlanması ve veri bağlamanın gerekliliği, kodun karmaşıklaşmasına ve bakımının zorlaşmasına neden olabilir.</li></ul><h3>XML ile RecyclerView ve Lazy Column Karşılaştırması</h3><h4>XML tabanlı RecyclerView:</h4><p>Karmaşık XML Dosyalarının Yönetimi:</p><ul><li>RecyclerView’un tanımlanması ve düzenlenmesi için genellikle karmaşık XML dosyaları kullanılır.</li><li>UI bileşenleri ve veri bağlantıları genellikle ayrı dosyalarda bulunur, bu da proje yönetimini karmaşıklaştırabilir.</li></ul><p>Adapter Sınıfının Tanımlanması ve Yönetimi:</p><ul><li>RecyclerView kullanılırken, veri setinin bağlanması ve gösterilmesi için bir Adapter sınıfının tanımlanması gereklidir.</li><li>Bu Adapter sınıfının oluşturulması, veri setinin güncellenmesi ve RecyclerView ile iletişim kurulması geliştirici tarafından yönetilmelidir.</li></ul><p>Performansın Optimizasyonu:</p><ul><li>RecyclerView kullanılırken, performansı optimize etmek geliştiricinin sorumluluğundadır.</li><li>Veri bağlantısı ve görünüm yeniden kullanımı gibi optimizasyonlar, geliştiricinin manuel olarak uygulanması gereken adımlardır.</li></ul><h4>Lazy Column:</h4><p>Kotlin Tabanlı Kod ile UI Bileşenlerinin Tanımlanması:</p><ul><li>Lazy Column, Kotlin dilini kullanarak UI bileşenlerinin tanımlandığı bir yapı sunar.</li><li>UI bileşenleri ve veri bağlantıları genellikle aynı Kotlin dosyasında bulunur, bu da kodun daha modüler ve okunabilir olmasını sağlar.</li></ul><p>Daha Okunabilir ve Esnek Bir Yapı:</p><ul><li>Kotlin dilinin esnekliği sayesinde, Lazy Column ile UI’nın oluşturulması ve özelleştirilmesi daha kolaydır.</li><li>Kodun daha temiz ve düzenli olması, bakımın daha kolay olmasını sağlar.</li></ul><p>Performansın Otomatik Olarak Yönetilmesi:</p><ul><li>Lazy Column, veri öğelerini dinamik olarak yükler ve ekranda görüntülendiği sürece saklar.</li><li>Performans optimizasyonu ve bellek yönetimi otomatik olarak gerçekleştirilir, bu da geliştiricinin ekstra çaba harcamasına gerek kalmaz.</li></ul><h4>LazyColumn (Jetpack Compose):</h4><pre>import androidx.compose.foundation.lazy.LazyColumn<br>import androidx.compose.foundation.lazy.items<br>import androidx.compose.runtime.Composable<br><br>@Composable<br>fun MyLazyColumn(dataList: List&lt;String&gt;) {<br>    LazyColumn {<br>        items(dataList) { item -&gt;<br>            // Liste öğesi<br>            Text(text = item)<br>        }<br>    }<br>}</pre><h4>RecyclerView/XML:</h4><pre>&lt;!-- activity_main.xml --&gt;<br>&lt;androidx.recyclerview.widget.RecyclerView<br>    android:id=&quot;@+id/recyclerView&quot;<br>    android:layout_width=&quot;match_parent&quot;<br>    android:layout_height=&quot;match_parent&quot; /&gt;</pre><pre>// MainActivity.kt<br>import androidx.appcompat.app.AppCompatActivity<br>import android.os.Bundle<br>import androidx.recyclerview.widget.LinearLayoutManager<br>import androidx.recyclerview.widget.RecyclerView<br><br>class MainActivity : AppCompatActivity() {<br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        setContentView(R.layout.activity_main)<br><br>        val dataList = listOf(&quot;Item 1&quot;, &quot;Item 2&quot;, &quot;Item 3&quot;, &quot;Item 4&quot;, &quot;Item 5&quot;)<br><br>        val recyclerView: RecyclerView = findViewById(R.id.recyclerView)<br>        recyclerView.layoutManager = LinearLayoutManager(this)<br>        recyclerView.adapter = MyAdapter(dataList)<br>    }<br>}</pre><pre>// MyAdapter.kt<br>import android.view.LayoutInflater<br>import android.view.View<br>import android.view.ViewGroup<br>import android.widget.TextView<br>import androidx.recyclerview.widget.RecyclerView<br><br>class MyAdapter(private val dataList: List&lt;String&gt;) : RecyclerView.Adapter&lt;MyAdapter.ViewHolder&gt;() {<br>    <br>    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {<br>        val view = LayoutInflater.from(parent.context).inflate(R.layout.list_item, parent, false)<br>        return ViewHolder(view)<br>    }<br><br>    override fun onBindViewHolder(holder: ViewHolder, position: Int) {<br>        holder.bind(dataList[position])<br>    }<br><br>    override fun getItemCount(): Int {<br>        return dataList.size<br>    }<br><br>    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {<br>        private val textView: TextView = itemView.findViewById(R.id.textView)<br><br>        fun bind(item: String) {<br>            textView.text = item<br>        }<br>    }<br>}</pre><p>Bu örnek, LazyColumn kullanarak bir liste oluşturmanın ve RecyclerView/XML kullanarak aynı liste görünümünü oluşturmanın nasıl yapıldığını gösteriyor. Kotlin kodu, Jetpack Compose kullanılarak daha basit ve okunabilir bir şekilde ifade edilirken, RecyclerView/XML yaklaşımı daha fazla dosya ve kod karmaşıklığı gerektirir.</p><p>Geleneksel XML tabanlı RecyclerView tanımlamaları, geliştiricilere karmaşık dosya yapıları ve manuel performans optimizasyonları gibi zorluklar yaşatabilirken, Jetpack Compose’un Lazy Column’uyla tanışmak, bu zorlukları ortadan kaldırmanın yeni bir yolu olabilir. Kotlin tabanlı kod ile UI bileşenlerinin tanımlanması, daha okunabilir ve esnek bir yapı sunarken, performansın otomatik olarak yönetilmesi de geliştiricilere zaman kazandırır. Adapter sınıfına veda ederek, Lazy Column gibi bileşenler sayesinde Android UI geliştirme süreci daha temiz, daha hızlı ve daha etkili hale gelebilir. Geleceğin Android uygulamalarını oluştururken, Jetpack Compose’un gücünü keşfetmek ve Lazy Column’un avantajlarından yararlanmak, geliştirme sürecini daha keyifli ve verimli hale getirebilir.</p><p><strong>Kaynak </strong>: <a href="https://developer.android.com/develop/ui/compose/lists">https://developer.android.com/develop/ui/compose/lists</a></p><p>Bu <a href="https://github.com/sumeyrapolat/JetpackComposeBasics">linke </a>tıklayarak Jetpack Compose ile yaptığım basic componentlerin nasıl yazıldığını inceleyebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=783b56b1bfce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose ile Navigation: Yenilikçi Bir Yaklaşım]]></title>
            <link>https://medium.com/@sumeyrapolat/jetpack-compose-ile-navigation-yenilik%C3%A7i-bir-yakla%C5%9F%C4%B1m-aece3946d343?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/aece3946d343</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Wed, 01 May 2024 15:01:41 GMT</pubDate>
            <atom:updated>2024-05-01T15:01:41.675Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ozJt4Oj0pZcV8m3CovLDBw.png" /></figure><p>Jetpack Compose, Android uygulama geliştirme dünyasına getirdiği yeniliklerle geliştiricilerin kullanıcı arayüzü oluşturma deneyimini kökten değiştiriyor. Bunlardan biri de Navigation bileşenidir. Geleneksel olarak, Android uygulamalarında ekranlar arası gezinme işlemleri, Navigation Component kütüphanesi kullanılarak yapılmaktadır. Ancak Jetpack Compose ile birlikte, bu deneyim daha sezgisel ve esnek bir şekilde sunulmaktadır.</p><p>Jetpack Compose ile Navigation kullanmanın avantajlarından biri, gezinme işlemlerinin bildirim tabanlı bir yaklaşımla gerçekleştirilmesidir. Bu, XML dosyaları üzerinde tanımlanan gezinme grafiğine ihtiyaç duyulmadan, doğrudan kod içinde gezinme yönergelerini belirlemenize olanak tanır.</p><h3>Temel Kavramlar</h3><p>Jetpack Compose ile Navigation kullanırken, bazı temel kavramları anlamak önemlidir:</p><ol><li><strong>NavHost</strong>: NavHost bileşeni, uygulamanın gezinme yapısını barındıran bir konteynerdir. Birden çok hedef ekranı destekleyebilir ve gezinme işlemlerini yönlendirir.</li><li><strong>NavHostController</strong>: NavHostController, uygulamanın gezinme durumunu yönetir. Ekranlar arası geçişleri işler ve uygulamanın mevcut durumunu takip eder.</li><li><strong>Route</strong>: Bir hedef ekranı temsil eden bir bileşendir. Jetpack Compose ile Navigation kullanırken, her bir ekran bir Route olarak tanımlanır.</li></ol><h3>Örnek Uygulama</h3><p>Şimdi, Jetpack Compose ile Navigation kullanarak basit bir örnek uygulama oluşturalım. Bu uygulama, Screen A ve Screen B ekranından oluşacaktır.</p><h4>Screen A</h4><pre>@Composable<br>fun ScreenA (navController: NavController) {<br>    Column (<br>        modifier = Modifier.fillMaxSize(),<br>        verticalArrangement = Arrangement.Center,<br>        horizontalAlignment = Alignment.CenterHorizontally<br>    ) {<br>        Text(text = &quot;Screen A&quot;)<br>        Spacer(modifier = Modifier.padding(10.dp))<br>        Button(onClick = {<br>            navController.navigate(Routes.screenB + &quot;/Sümeyra Polat&quot;)<br>        }) {<br>            Text(text = &quot;Go To Screen B&quot;)<br>        }<br>    }<br>}</pre><h4>Screen B</h4><pre>@Composable<br>fun ScreenB (name : String) {<br>    Column(<br>        modifier = Modifier.fillMaxSize(),<br>        verticalArrangement = Arrangement.Center,<br>        horizontalAlignment = Alignment.CenterHorizontally<br>    ) {<br>        Text(text = &quot;Screen B and Argument:$name&quot;)<br>    }<br>}</pre><p>ScreenA ve ScreenB Composable Fonksiyonları:</p><ul><li>ScreenA: Bu fonksiyon, Screen A&#39;nın arayüzünü oluşturur. Bir navController parametresi alır. Column içinde bir metin (Text) ve bir düğme (Button) bulunur. Düğmeye tıklandığında, navController.navigate ile Routes.screenB&#39;ye geçiş yapılır ve bir parametre (&quot;Sümeyra Polat&quot;) iletilir.</li><li>ScreenB: Bu fonksiyon, Screen B&#39;nin arayüzünü oluşturur. Bir name parametresi alır ve bu parametreyi kullanarak bir metin (Text) gösterir.</li></ul><h4>Routes</h4><pre>object Routes {<br>    var screenA = &quot;screen_A&quot;<br>    var screenB = &quot;screen_B&quot;<br>}</pre><p>Routes Objesi:</p><ul><li>Routes: Bu obje, uygulama içinde kullanılan ekran rotalarını içerir. screenA ve screenB olmak üzere iki sabit değişken içerir.</li></ul><h4>AppNavigation</h4><pre><br>@Composable<br>fun AppNavigation(){<br>    val navController = rememberNavController()<br>    NavHost(navController = navController, startDestination = Routes.screenA) {<br>        composable(Routes.screenA){<br>            ScreenA(navController)<br>        }<br>        composable(Routes.screenB +&quot;/{name}&quot;){<br>            val name =it.arguments?.getString(&quot;name&quot;)<br>            ScreenB(name?:&quot;No name!&quot;)<br>        }<br>    }<br>}</pre><p>AppNavigation Fonksiyonu:</p><ul><li>AppNavigation: Bu fonksiyon, uygulamanın navigasyonunu yönetir. rememberNavController ile bir navController oluşturulur. NavHost içinde, startDestination olarak Routes.screenA belirlenir ve ScreenA ve ScreenB ekranlarına geçişler belirtilir. Routes.screenB + &quot;/{name}&quot; ifadesi, Screen B&#39;ye geçiş yaparken bir parametre iletilmesini sağlar. Bu parametre, ScreenB fonksiyonunda kullanılır.</li></ul><h4>Main Activity</h4><pre>class MainActivity : ComponentActivity() {<br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        setContent {<br>            AppNavigation()<br>        }<br>    }<br>}</pre><p>MainActivity Sınıfı:</p><ul><li>MainActivity: Bu sınıf, uygulamanın ana aktivitesini temsil eder. onCreate metodunda, setContent ile AppNavigation fonksiyonu çağrılır ve uygulamanın içeriği olarak ayarlanır.</li></ul><p>Bu şekilde, AppNavigation fonksiyonu aracılığıyla Jetpack Compose Navigation kullanarak, ScreenA ve ScreenB arasında geçiş yapabilir ve parametre aktarımı gerçekleştirebilirsiniz. Bu kod parçaları, Jetpack Compose ile uygulama navigasyonunu yönetmenin temel bir örneğini sunar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*zyElqDBuFoBOui4GUPa1CQ.png" /><figcaption>dizin kontrolü</figcaption></figure><h3>Sonuç</h3><p>Jetpack Compose ile Navigation, Android uygulama geliştirme sürecini daha kolay ve esnek hale getiriyor. Bildirim tabanlı gezinme yaklaşımı, kodun daha okunabilir olmasını sağlar ve XML dosyaları üzerindeki bağımlılığı azaltır. Bu, geliştiricilere daha hızlı ve daha verimli uygulama geliştirme deneyimi sunar.</p><p>Jetpack Compose ile Navigation hakkında daha fazla bilgi için <a href="https://developer.android.com/jetpack/compose/navigation">resmi dokümantasyona</a> göz atabilirsiniz.</p><p>Bu yazıda, Jetpack Compose ile Navigation’un temel kavramlarına ve bir örnek uygulamaya değindik. Umarım bu yazı, Jetpack Compose kullanıcılarına gezinme konusunda daha derinlemesine anlayış sağlar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aece3946d343" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose ile Giriş Ekranı Oluşturma (Login Page)]]></title>
            <link>https://medium.com/@sumeyrapolat/jetpack-compose-ile-giri%C5%9F-ekran%C4%B1-olu%C5%9Fturma-login-page-c745b9fe2970?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c745b9fe2970</guid>
            <category><![CDATA[jetpack-compose]]></category>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Tue, 30 Apr 2024 10:56:41 GMT</pubDate>
            <atom:updated>2024-04-30T11:00:19.344Z</atom:updated>
            <content:encoded><![CDATA[<p>Android uygulamaları geliştirmek için Jetpack Compose, geleneksel XML tabanlı kullanıcı arayüzü yerine Kotlin tabanlı bir arayüz oluşturma yaklaşımını sunar. Bu kılavuzda, Android Studio’da Jetpack Compose’u kullanarak bir giriş ekranı oluşturmayı öğreneceksiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*4044ypyV4h-oShNJ9iJiNA.jpeg" /></figure><h4><strong>1. Giriş Ekranı Tasarımı</strong></h4><p>Jetpack Compose’u kullanarak bir giriş ekranı oluşturmak için LoginScreen adında bir Composable fonksiyon oluşturduk. Bu fonksiyon, giriş ekranının tüm bileşenlerini içerir.</p><pre>@Composable<br>fun LoginScreen() {</pre><h4>2. State’lerin Tanımlanması</h4><p>E-posta ve şifre girişi için kullanıcıdan alınacak verileri saklamak için mutableStateOf kullanarak iki değişken tanımlıyoruz.</p><pre>val email = remember { mutableStateOf(&quot;&quot;) }<br>val password = remember { mutableStateOf(&quot;&quot;) }</pre><h4>3. Ekran Düzeni</h4><p>Bir sütun oluşturarak ekranın düzenini belirliyoruz. Bu sütun, diğer bileşenlerin dikey olarak üst üste gelmesini sağlar.</p><pre>Column(<br>    modifier = Modifier<br>        .fillMaxSize()<br>        .padding(horizontal = 16.dp),<br>    verticalArrangement = Arrangement.Center,<br>    horizontalAlignment = Alignment.CenterHorizontally<br>) {</pre><h4>4. Logo Ekleme</h4><p>Uygulamanın logosunu Image bileşeniyle ekliyoruz. painterResource ile drawable kaynağını kullanıyoruz.</p><pre>Image(<br>    painter = painterResource(id = R.drawable.ic_launcher_foreground),<br>    contentDescription = &quot;Logo&quot;,<br>    modifier = Modifier.size(150.dp)<br>)</pre><h4>5. E-posta Alanı</h4><p>Kullanıcıdan e-posta almak için OutlinedTextField kullanıyoruz. Kullanıcı e-posta girdiğinde onValueChange ile değeri güncelliyoruz.</p><pre>OutlinedTextField(<br>    value = email.value,<br>    onValueChange = { email.value = it },<br>    label = { Text(text = stringResource(id = R.string.email_label)) },<br>    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),<br>    keyboardActions = KeyboardActions(onNext = { /* Handle Next */ })<br>)</pre><h4>6. Şifre Alanı</h4><p>Kullanıcıdan şifre almak için de OutlinedTextField kullanıyoruz. Şifrenin görünürlüğünü gizlemek için visualTransformation özelliğini kullanıyoruz.</p><pre>OutlinedTextField(<br>    value = password.value,<br>    onValueChange = { password.value = it },<br>    label = { Text(text = stringResource(id = R.string.password_label)) },<br>    visualTransformation = PasswordVisualTransformation(),<br>    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),<br>    keyboardActions = KeyboardActions(onDone = {<br>        // Giriş işlemini gerçekleştir<br>        Toast.makeText(context, &quot;Login clicked&quot;, Toast.LENGTH_SHORT).show()<br>    })<br>)</pre><h4>7. Giriş Butonu</h4><p>Giriş işlemini gerçekleştirmek için bir buton ekliyoruz. Butona tıklandığında giriş işlemi yapılacak.</p><pre>Button(onClick = {<br>    // Giriş işlemini gerçekleştir<br>    Toast.makeText(context, &quot;Login clicked&quot;, Toast.LENGTH_SHORT).show()<br>}) {<br>    Text(text = stringResource(id = R.string.login_button))<br>}</pre><h4>8. Önizleme Fonksiyonu</h4><p>@Preview ve PreviewLoginScreen fonksiyonları ile giriş ekranının önizlemesini sağlıyoruz.</p><pre>@Preview<br>@Composable<br>fun PreviewLoginScreen() {<br>    LoginScreen()<br>}</pre><p>Kaynak kodlarına <a href="https://github.com/sumeyrapolat/LoginPageCompose">buradan</a> ulaşabilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/150/1*4UkBXgVEpbxFDTousBg9Rw.png" /><figcaption>UI Ekran Görüntüsü</figcaption></figure><p>Kaynak: <a href="https://developer.android.com/develop/ui/compose">https://developer.android.com/develop/ui/compose</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c745b9fe2970" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jetpack Compose: State Management ve Recomposition]]></title>
            <link>https://medium.com/@sumeyrapolat/jetpack-compose-state-management-ve-recomposition-1ed2623e605c?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ed2623e605c</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Thu, 25 Apr 2024 13:00:48 GMT</pubDate>
            <atom:updated>2024-04-25T13:15:42.109Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSmtgcs2nyqgpJsHtUOxcQ.png" /></figure><h3>State Management Nedir?</h3><p>State management, bir uygulamanın durumunu yönetme sürecidir. Durum, uygulamanın kullanıcı arayüzünde görünen verilerin, kullanıcı etkileşimlerinin ve uygulama durumunun genel durumunu ifade eder. Jetpack Compose’ta, state management, uygulamanın durumunu değiştiren ve bu değişikliklerin kullanıcı arayüzünde nasıl yansıtılacağını belirleyen bir dizi araç ve yöntemi içerir.</p><h3>State Management’in İşlevleri:</h3><ol><li><strong>State</strong>: Jetpack Compose’ta, bir bileşenin durumu, mutableStateOf veya mutableStateListOf gibi fonksiyonlarla oluşturulan değişkenler kullanılarak tanımlanır. Bu durumlar, uygulamanın dinamik verilerini ve kullanıcı etkileşimlerini temsil eder.</li><li><strong>State Hoisting:</strong> State hoisting, bir bileşenin durumunu üst düzeye çıkarma işlemidir. Böylece, birden çok bileşen arasında paylaşılan durumlar kullanılabilir. Bu, uygulamanın durumunu tek bir kaynaktan yönetmeyi kolaylaştırır ve veri tutarsızlığını önler.</li><li><strong>ViewModel:</strong> Jetpack Compose ile birlikte, Android Jetpack kütüphanesinin bir parçası olan ViewModel kullanılabilir. ViewModel, uygulamanın durumunu tutar ve yaşam döngüsü değişikliklerinden etkilenmeden veri saklar. Compose tarafından sunulan viewModel yardımcı fonksiyonuyla, ViewModel&#39;leri kullanmak oldukça kolaydır.</li><li><strong>Effect:</strong> Compose, bir bileşenin durum değişikliklerine yanıt olarak yan etkileri (örneğin, ağ istekleri veya veritabanı işlemleri gibi) yönetmek için LaunchedEffect ve DisposableEffect gibi araçlar sunar.</li></ol><h3>Recomposition Nedir?</h3><p>Recomposition, bir bileşenin durumunda bir değişiklik olduğunda, Compose’un otomatik olarak bu bileşenin yeniden oluşturulmasını sağlayan bir süreçtir. Yani, bir bileşenin durumu değiştiğinde, Compose otomatik olarak bu bileşeni sıfırdan yeniden oluşturur ve güncel durumu temsil eden bir arayüz sunar. Bu, geliştiricilerin, uygulamanın nasıl görüneceğini manuel olarak güncellemek zorunda kalmadan, sadece verilerin nasıl değiştiğine odaklanmasını sağlar.</p><p>Recomposition, performansı optimize eden birçok akıllı algoritmaya dayanır. Compose, her bileşenin yalnızca değişen kısımlarını günceller, böylece gereksiz yeniden oluşturma işlemlerinden kaçınılır.</p><p>Bir bileşenin durumu değiştiğinde, Compose, aşağıdaki adımları izler:</p><ol><li><strong>State Değişikliği Algılama:</strong> Bir bileşenin durumunda bir değişiklik olduğunda, Compose bu değişikliği algılar.</li><li><strong>Bileşen Yeniden Oluşturma:</strong> Değişiklik algılandığında, Compose, etkilenen bileşeni sıfırdan yeniden oluşturur.</li><li><strong>Yeniden Oluşturulan Bileşenin Güncellenmesi:</strong> Yeniden oluşturulan bileşen, güncel durumu temsil eden bir arayüz sunar.</li></ol><p>Recomposition, geliştiricilerin kodlarını daha basit ve anlaşılabilir kılar, çünkü güncellenmesi gereken her şeyi manuel olarak takip etmek zorunda kalmazlar. Bu, uygulamaların daha kolay bakımını ve geliştirilmesini sağlar.</p><h3>Jetpack Compose Öncesinde XML’de State Management Kullanımı</h3><p>Jetpack Compose öncesi Android uygulamalarında da state management yönetimi bulunmaktaydı. Ancak, Jetpack Compose’tan önce kullanılan araçlar ve yöntemler, genellikle daha geleneksel ve klasik Android geliştirme yöntemleriydi. Bu yöntemler arasında şunlar bulunmaktadır:</p><ol><li><strong>Activity ve Fragment Lifecycle: </strong>Android uygulamalarında, Activity ve Fragment yaşam döngüsü yönetimi, genellikle uygulamanın durumunu takip etmek ve yönetmek için kullanılırdı. Ancak, bu yöntem, büyük ve karmaşık uygulamalarda durum yönetimini karmaşıklaştırabilir ve hata eğilimli olabilir.</li><li><strong>LiveData ve ViewModel:</strong> Android Architecture Components kütüphanesinde bulunan LiveData ve ViewModel, uygulamanın durumunu yönetmek için yaygın olarak kullanılan araçlardı. LiveData, veri akışını temsil ederken, ViewModel, uygulamanın arayüz bağımsız mantığını sağlar. Bu, özellikle veri değişikliklerini UI güncellemeleriyle senkronize etmek için kullanışlıydı.</li><li><strong>RxJava: </strong>RxJava, reaktif programlama prensiplerine dayanan bir kütüphanedir. Veri akışlarını, olayları ve asenkron işlemleri yönetmek için kullanılır. RxJava, uygulamanın durumunu yönetmek ve UI güncellemelerini kolaylaştırmak için kullanılabilirdi.</li><li><strong>SharedPreferences ve Veritabanı:</strong> Basit uygulamalarda, SharedPreferences kullanılarak küçük veri parçaları saklanabilirken, daha karmaşık uygulamalarda SQLite gibi yerel veritabanları kullanılabilir. Bu, uygulamanın kalıcı durumunu yönetmek için kullanılan bir başka yaklaşımdır.</li></ol><p>Ancak, bu yöntemler genellikle daha karmaşık ve hata eğilimli olabilir ve geliştiricilerin uygulamanın durumunu doğru şekilde yönetmesini zorlaştırabilir. Jetpack Compose, state management’i daha basitleştirmek ve geliştirmek için tasarlanmıştır, böylece geliştiriciler UI bileşenlerini daha kolay bir şekilde yönetebilir ve güncelleyebilirler.</p><h3>Jetpack Compose State Management ile Android Lifecycle Yönetimi</h3><p>Jetpack Compose kullanırken state management ve lifecycle yönetimi birlikte çalışır, ancak geleneksel Android geliştirme yöntemlerinden farklıdır. Jetpack Compose, UI bileşenlerini oluşturmak için bir dizi fonksiyonel yaklaşım sunar ve bu, state management ve lifecycle yönetimini daha basit ve tutarlı hale getirir. İşte Jetpack Compose kullanımında state management ve lifecycle yönetiminin nasıl işlediğine dair birkaç anahtar nokta:</p><h3>State Management:</h3><p><strong>State:</strong></p><ul><li>Jetpack Compose’ta, bileşenlerin durumu remember fonksiyonu ile tanımlanır. Bu, uygulamanın durumunu temsil eden değişkenleri saklamak için kullanılır. Örneğin, remember fonksiyonu, bir dizeyi veya bir sayıyı saklamak için kullanılabilir.</li></ul><pre>val count = remember { mutableStateOf(0) }</pre><p><strong>State Hoisting:</strong></p><ul><li>Birden çok bileşen arasında durum paylaşmak için state hoisting kullanılır. Bu, bir bileşenin durumunu üst düzeye çıkarmak ve bu durumu diğer bileşenlerle paylaşmak anlamına gelir. Böylece, uygulamanın durumunu merkezi bir yerden yönetmek mümkün olur.</li></ul><p><strong>ViewModel:</strong></p><ul><li>Jetpack Compose ile birlikte, Android Jetpack kütüphanesinin bir parçası olan ViewModel kullanılabilir. ViewModel, uygulamanın durumunu tutar ve yaşam döngüsü değişikliklerinden etkilenmeden veri saklar. Bu, özellikle uygulamanın kalıcı durumunu yönetmek için kullanışlıdır.</li></ul><h3>Lifecycle Yönetimi:</h3><h4>LifecycleAwareEffect:</h4><ul><li>Jetpack Compose, bileşenlerin yaşam döngüsü değişikliklerine tepki vermesini sağlamak için LaunchedEffect ve DisposableEffect gibi LifecycleAwareEffect&#39;leri sağlar. Bu, bir bileşenin yaratılması, yok edilmesi veya yeniden oluşturulması gibi yaşam döngüsü olaylarına tepki vermek için kullanılabilir.</li></ul><h4>LifecycleScope:</h4><ul><li>LifecycleScope, bir bileşenin yaşam döngüsüne bağlı olarak çalışan işlemleri başlatmak için kullanılır. Bu, coroutine’lerin yaşam döngüsüne uyumlu hale getirilmesini sağlar ve bellek sızıntılarını önler.</li></ul><pre>@Composable<br>fun CounterScreen(viewModel: CounterViewModel = viewModel()) {<br>    val count = viewModel.count.observeAsState()<br><br>    Column(<br>        modifier = Modifier.fillMaxSize(),<br>        verticalArrangement = Arrangement.Center,<br>        horizontalAlignment = Alignment.CenterHorizontally<br>    ) {<br>        Text(text = &quot;Count: ${count.value}&quot;)<br>        Button(onClick = { viewModel.increment() }) {<br>            Text(text = &quot;Increment&quot;)<br>        }<br>    }<br>}</pre><p>Yukarıdaki örnekte, CounterScreen isimli bir Composable fonksiyon tanımlanmıştır. Bu fonksiyon, CounterViewModel isimli bir ViewModel&#39;i kullanır ve ViewModel&#39;den gelen count state&#39;ini gösterir. Kullanıcı bir butona tıkladığında, ViewModel&#39;deki count değeri artırılır. Bu sayede state management ve lifecycle yönetimi bir arada kullanılmış olur.</p><p>Kaynak: <a href="https://developer.android.com/develop/ui/compose">https://developer.android.com/develop/ui/compose</a><br>Kaynak: Android Mobil Uygulama Kursu : Java &amp; Kotlin (Bölüm 32)<br><a href="https://medium.com/u/4518d39650ba">Atıl Samancıoğlu</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ed2623e605c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Uygulama Geliştiricileri için Jetpack Compose: Geleneksel XML’e Veda Edin!]]></title>
            <link>https://medium.com/@sumeyrapolat/android-uygulama-geli%C5%9Ftiricileri-i%C3%A7in-jetpack-compose-geleneksel-xmle-veda-edin-3f88b367aeef?source=rss-4d07eccbf96b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f88b367aeef</guid>
            <dc:creator><![CDATA[Sümeyra Polat]]></dc:creator>
            <pubDate>Wed, 24 Apr 2024 19:04:25 GMT</pubDate>
            <atom:updated>2024-04-25T13:16:44.241Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZ78dXWJPosWgwGM-p4LWw.png" /></figure><h3>Jetpack Compose Nedir ?</h3><p>Jetpack Compose, Android uygulamalarında kullanıcı arayüzlerini modern ve etkileyici bir şekilde oluşturmanıza olanak tanıyan yeni bir yaklaşımdır. Geleneksel XML tabanlı kullanıcı arayüzü oluşturma yöntemlerinden farklı olarak, Jetpack Compose, Kotlin dilinin gücünü kullanarak deklaratif bir şekilde UI tasarlamanıza imkan sağlar. Bu, geliştiricilere daha esnek, okunabilir ve yeniden kullanılabilir kodlar yazma olanağı sunar.</p><p>Bu yazıda, Jetpack Compose’un temel bileşenlerini öğrenerek Android uygulamalarınızda nasıl kullanabileceğinizi keşfedeceksiniz. Column ve Row gibi düzen bileşenlerini kullanarak bileşenleri dikey ve yatay olarak nasıl hizalayacağınızı, Modifier ile bileşenleri özelleştirme tekniklerini, ve daha fazlasını öğreneceksiniz. Ayrıca, uygulamanızın görünümünü ve davranışını kolayca önizleyebileceğiniz gelişmiş bir önizleme sistemi hakkında bilgi edineceksiniz.</p><p>Jetpack Compose’un getirdiği bu yenilikçi yaklaşım, Android uygulama geliştiricilerine daha hızlı, daha esnek ve daha verimli bir şekilde kullanıcı arayüzü tasarlama fırsatı sunuyor. Hazır olun, çünkü geleneksel XML’e veda etme ve Jetpack Compose’un gücünü keşfetme zamanı geldi!</p><h4>Jetpack Compose’un Özellikleri:</h4><ul><li>Kolay öğrenme eğrisi: Compose, Kotlin bilgisi olan herhangi bir Android geliştiricisi tarafından kolayca öğrenilebilir.</li><li>Geliştirilmiş üretkenlik: Compose, UI oluşturmayı daha hızlı ve daha kolay hale getirir.</li><li>Daha az kod: Compose kullanarak, aynı işlevselliği sağlamak için daha az kod yazmanız gerekir.</li><li>Daha iyi performans: Compose, UI’yi daha verimli bir şekilde oluşturur ve günceller.</li><li>Daha tutarlı kullanıcı deneyimi: Compose, farklı cihaz boyutları ve ekran yoğunluklarında tutarlı bir kullanıcı deneyimi sağlar.</li></ul><h4>Jetpack Compose’un Faydaları:</h4><ul><li>Geliştiriciler için daha iyi: Compose, geliştiricilerin daha üretken olmasını ve daha iyi kullanıcı deneyimleri oluşturmasını sağlar.</li><li>Kullanıcılar için daha iyi: Compose, kullanıcıların daha akıcı ve daha duyarlı uygulamalar deneyimlemesini sağlar.</li><li>İşletmeler için daha iyi: Compose, işletmelerin daha hızlı ve daha düşük maliyetle yüksek kaliteli uygulamalar geliştirmesini sağlar.</li></ul><h4>Composable Nedir?</h4><p>Composable, bir kullanıcı arayüzü (UI) çerçevesinde yeniden kullanılabilir bir yapı taşıdır. Diğer composable’larla birleştirilerek daha karmaşık kullanıcı arayüzleri oluşturulabilen kendi kendine yeten bir bileşendir. Composable fonksiyonları, Kotlin’de<strong> @Composable</strong> anotasyonu kullanılarak tanımlanır</p><h4>Composable’ın Özellikleri:</h4><ul><li>Durumsuz: Composable fonksiyonları durumsuz olmalıdır, yani herhangi bir dahili durumu saklamamalıdır. Bu, kullanıcı arayüzünün tutarlı ve öngörülebilir kalmasını sağlar.</li><li>Değişmez: Composable fonksiyonları, girdi parametrelerini değiştirmemelidir. Bunun yerine, güncellenmiş değerlerle yeni composable örnekleri oluşturmalıdır.</li><li>Yan etkisiz: Composable fonksiyonları, ağ istekleri veya veritabanı işlemleri gibi herhangi bir yan etki yapmamalıdır. Bu işlemler, geri aramalar veya coroutine’ler gibi diğer mekanizmalar tarafından ele alınmalıdır.</li></ul><h4>Composable Kullanmanın Faydaları:</h4><ul><li>Geliştirilmiş performans: Composable fonksiyonları, yalnızca girdi parametreleri değiştiğinde yeniden oluşturulduğu için performans için optimize edilmiştir.</li><li>Artırılmış modülerlik: Composable fonksiyonları, daha karmaşık kullanıcı arayüzleri oluşturmak için kolayca birleştirilebilir ve yeniden kullanılabilir.</li><li>Geliştirilmiş test edilebilirlik: Composable fonksiyonları, kendi kendine yeten ve iyi tanımlanmış girdilere ve çıktılara sahip oldukları için test edilmesi daha kolaydır.</li></ul><h3>Başlangıç</h3><p>Jetpack Compose ile başlamak için, öncelikle projenize Compose kütüphanesini eklemeniz gerekir. Bu, projenizin build.gradle dosyasına gerekli bağımlılıkları eklemekle yapılabilir:</p><pre>dependencies {<br>    implementation &quot;androidx.compose.ui:ui:1.0.0&quot;<br>    implementation &quot;androidx.compose.material:material:1.0.0&quot;<br>    // Diğer gerekli bağımlılıklar<br>}</pre><h3>Temel Bileşenler</h3><h4>Column ve Row</h4><p>Column ve Row bileşenleri, dikey ve yatay düzenler oluşturmak için kullanılır. Column, içine eklenen bileşenleri üstten alta doğru sıralar, Row ise soldan sağa doğru sıralar. Örneğin:</p><pre>Column {<br>    Text(text = &quot;Birinci Satır&quot;)<br>    Text(text = &quot;İkinci Satır&quot;)<br>}</pre><pre>Row {<br>    Text(text = &quot;Soldan&quot;)<br>    Text(text = &quot;Sağa&quot;)<br>}</pre><h4>Box</h4><p>Box, Jetpack Compose’da içerisine birden fazla bileşen yerleştirebileceğiniz ve bunları istediğiniz şekilde düzenleyebileceğiniz bir bileşendir. Genellikle, Box bileşeni içerisinde diğer bileşenleri özgürce yerleştirmek ve düzenlemek için kullanılır. Örneğin:</p><pre>Box(<br>    modifier = Modifier<br>        .size(200.dp)<br>        .background(color = Color.Blue)<br>) {<br>    Text(<br>        text = &quot;Merhaba, Compose!&quot;,<br>        color = Color.White,<br>        modifier = Modifier.align(Alignment.Center)<br>    )<br>}</pre><h4>Modifier</h4><p>Modifier, bileşenlerinizi düzenlemek ve özelleştirmek için kullanılan bir araçtır. Modifier kullanarak bileşenlerin boyutunu, arka planını, kenar boşluklarını ve daha fazlasını ayarlayabilirsiniz. Örneğin:</p><pre>Box(<br>    modifier = Modifier<br>        .size(200.dp)<br>        .background(color = Color.Blue)<br>) {<br>    Text(<br>        text = &quot;Merhaba, Compose!&quot;,<br>        color = Color.White,<br>        modifier = Modifier.align(Alignment.Center)<br>    )<br>}</pre><h4>Alignment ve Arrangement</h4><p>Alignment ve Arrangement, bileşenlerinizi dikey veya yatay düzende hizalamak için kullanılan araçlardır. Alignment bileşenlerin hizalanma yöntemini belirtirken, Arrangement bileşenlerin sıralanma yöntemini belirtir. Örneğin:</p><pre>Column(<br>    verticalArrangement = Arrangement.Center,<br>    horizontalAlignment = Alignment.CenterHorizontally<br>) {<br>    // Bileşenler buraya eklenecek<br>}</pre><p>Bu temel bileşenler ve özellikler, Jetpack Compose’u kullanarak Android uygulamalarında güçlü ve esnek kullanıcı arayüzleri oluşturmanın anahtarıdır.</p><p>Kaynak: <a href="https://developer.android.com/develop/ui/compose">https://developer.android.com/develop/ui/compose</a><br>Kaynak: Android Mobil Uygulama Kursu : Java &amp; Kotlin (Bölüm 31) <a href="https://medium.com/u/4518d39650ba">Atıl Samancıoğlu</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f88b367aeef" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>