<?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 Cenker Aydın on Medium]]></title>
        <description><![CDATA[Stories by Cenker Aydın on Medium]]></description>
        <link>https://medium.com/@cenkeraydin14?source=rss-a4d078479e25------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*didXzuyw1s8ivbngz1jvBQ.jpeg</url>
            <title>Stories by Cenker Aydın on Medium</title>
            <link>https://medium.com/@cenkeraydin14?source=rss-a4d078479e25------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 22:30:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cenkeraydin14/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[Managing Side Effects in Jetpack Compose]]></title>
            <link>https://proandroiddev.com/managing-side-effects-in-jetpack-compose-6adafff83b59?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/6adafff83b59</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[compose]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Fri, 16 May 2025 10:42:35 GMT</pubDate>
            <atom:updated>2025-05-21T09:45:59.461Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*hGH3umXQJ_e64H7nfUrzzw.png" /></figure><p>🖐 <strong>Hello everyone!</strong></p><p>Today, we’re going to talk about a common issue in Android app development: <strong>Side Effects</strong>.</p><p>Side effects often go unnoticed, yet they can have a <strong>significant impact on user experience and app performance</strong>. In this article, we’ll explore what side effects are in the context of Android applications, when and why they occur, and most importantly, <strong>how to effectively handle them</strong> in your projects.</p><p><strong>What Are Side Effects?</strong><br> Side effects refer to operations performed by a Composable function that go beyond its primary responsibility of generating UI. While a Composable is mainly expected to render the UI, it might also perform additional actions such as writing to a database, making API calls, reading/writing files, displaying a Snackbar message, logging, and so on. These kinds of operations are considered side effects because they involve interaction with the application’s state or the outside world.</p><p>Such effects must be managed in a way that aligns with the declarative and reactive nature of Jetpack Compose. Otherwise, it can lead to performance issues, unexpected behavior, and potentially memory leaks — ultimately harming the user experience.</p><p>We need to manage these effects correctly in order to enhance user experience and optimize application performance. Otherwise, we might encounter lags, freezes, or other undesirable behavior, which is something we definitely want to avoid. This is exactly where <strong>Effect Handlers</strong> come into play — they provide a structured way to handle side effects more effectively.</p><p><strong>What Are Effect Handlers?</strong><br> Jetpack Compose provides various <strong>Effect Handlers</strong> to manage side effects in a safe and efficient way. Without using these structures, side effects could block the UI thread, which would severely impact application performance and the overall user experience.</p><p><strong>LaunchedEffect</strong><br> LaunchedEffect is used for asynchronous operations that need to run either once or under specific conditions, depending on the lifecycle of a Composable. Since LaunchedEffect is a Composable function, it can only be used within other Composable functions. It utilizes suspend functions to perform its operations and works seamlessly with coroutines. It can take one or more key parameters, and it gets triggered either when the Composable is first composed or when any of the provided keys change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wxtbckQEWPvBd2EkyttFjA.png" /><figcaption>LaunchedEffect function</figcaption></figure><p>To help better understand how LaunchedEffect works, I’ve shared an example on my GitHub account.<br>For those who are interested, feel free to check it out here:</p><p><a href="https://github.com/CenkerAydin/SideEffects">GitHub - CenkerAydin/SideEffects</a></p><p><strong>rememberCoroutineScope</strong><br>rememberCoroutineScope is used to create a coroutine scope that is tied to the lifecycle of a Composable. This means that if the associated Composable is removed from the composition—such as during a screen transition or recomposition—the created coroutine scope is automatically cancelled. This behavior contributes to performance optimization by preventing unnecessary resource usage.</p><p>When you need to launch a coroutine from an event handler — such as inside a button’s onClick block—rather than directly within the body of a Composable function, you should use rememberCoroutineScope instead of LaunchedEffect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dCS-s1VUTtVyMN0Ufy5zxQ.png" /><figcaption>rememberCoroutineScope yapısı</figcaption></figure><p><strong>rememberUpdatedState</strong></p><p>In LaunchedEffect, the effect is re-executed whenever the provided keys change. However, there are cases where we don&#39;t want the coroutine to restart even if some values used inside the effect change. In such situations, we should use rememberUpdatedState.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*uRngv8I6R011jPhpMtOicw.png" /><figcaption>rememberUpdatedState yapısı</figcaption></figure><p><strong>DisposableEffect</strong><br> Some side effects need to be <strong>cleaned up</strong> when they are no longer needed. For example:</p><ul><li>If you’ve registered a listener (observer), you should remove it when it’s no longer necessary.</li><li>If you’ve added a BroadcastReceiver, you should unregister it when it&#39;s not being used.</li><li>If you’ve opened a resource (such as a socket connection), you should close it when exiting.</li></ul><p>In such cases, DisposableEffect should be used to handle both the setup and the cleanup of the effect. It provides a safe way to manage external resources within the lifecycle of a Composable.</p><p><strong>SideEffect</strong><br> SideEffect is used to send data or updates to <strong>objects not managed by Compose</strong>. It runs <strong>after every successful composition or recomposition</strong>.<br> This is useful when you need to synchronize <strong>Compose-managed state with external systems</strong> that are not part of the Compose UI hierarchy.</p><h3>Conclusion</h3><p>Properly managing side effects in Jetpack Compose is essential for the performance, reliability, and overall user experience of your application. Tools like LaunchedEffect, rememberCoroutineScope, rememberUpdatedState, DisposableEffect, and SideEffect allow us to handle side effects in a way that aligns with Compose’s reactive and declarative nature.</p><p>Each of these effect handlers serves a specific purpose and helps keep your code clean, efficient, and maintainable. As your app grows in size and complexity, using these tools correctly will make debugging easier and provide a smoother experience for your users.</p><p>Remember, Compose is not just about drawing UI — it also brings a set of powerful mechanisms that every modern Android developer should understand and use effectively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/384/1*Mm_87bFP2XMjaZBglYbyHQ.gif" /><figcaption><a href="https://giphy.com/gifs/3oEdva9BUHPIs2SkGk">Source</a></figcaption></figure><p>Thanks for reading! See you in future posts.</p><p><strong>References</strong></p><ul><li><a href="https://developer.android.com/develop/ui/compose/side-effects#state-effect-use-cases">Side-effects in Compose | Jetpack Compose | Android Developers</a></li><li><a href="https://newsletter.jorgecastillo.dev/p/jetpack-compose-effect-handlers?source=post_page-----971d86adc271---------------------------------------">Jetpack Compose Effect Handlers</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6adafff83b59" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/managing-side-effects-in-jetpack-compose-6adafff83b59">Managing Side Effects in Jetpack Compose</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Side Effects ve Etkili Yönetimi: Compose Dünyasında Temiz Kodun Sırrı]]></title>
            <link>https://medium.com/@cenkeraydin14/side-effects-ve-etkili-y%C3%B6netimi-compose-d%C3%BCnyas%C4%B1nda-temiz-kodun-s%C4%B1rr%C4%B1-e590a3a2b573?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/e590a3a2b573</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[compose]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Fri, 16 May 2025 10:42:28 GMT</pubDate>
            <atom:updated>2025-05-16T10:42:28.348Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*hGH3umXQJ_e64H7nfUrzzw.png" /></figure><p>🖐 <strong>Selamlar!</strong></p><p>Bugün sizlerle Android uygulama geliştirme sürecinde sıkça karşılaştığımız bir konudan, <strong>“Side Effect” (Yan Etkiler)</strong> probleminden bahsedeceğiz.</p><p>Yan etkiler, uygulamanın <strong>kullanıcı deneyimi</strong> ve <strong>performansı</strong> üzerinde doğrudan etkisi olan, ancak genellikle gözden kaçan önemli bir problemdir. Bu yazıda, Android uygulamalarda yan etkilerin ne olduğuna, hangi durumlarda karşımıza çıktığına ve bu sorunlara <strong>nasıl etkili bir şekilde yaklaşabileceğimize</strong> birlikte göz atacağız.</p><h4><strong>Side Effects Nedir?</strong></h4><p>Side Effects, bir Composable fonksiyonun ana işlevi olan UI oluşturma süreci dışında gerçekleşen ve uygulamanın durumu veya dış dünya ile etkileşime giren işlemleri ifade eder. Yani, bir Composable fonksiyonun yalnızca UI çizmesi beklenirken, bu fonksiyonun veritabanına yazma, API çağrısı yapma, dosya okuma/yazma, Snackbar mesajı gösterme, log kaydı yapma gibi ek işlemler yapması side effect olarak adlandırılır. Bu tür işlemler, Compose’un deklaratif ve reaktif doğasına uygun şekilde yönetilmelidir, aksi takdirde uygulama performansı düşebilir, beklenmeyen davranışlar ortaya çıkabilir ve bu durum kullanıcı deneyimini olumsuz etkileyebilir veya hafıza sızıntıları oluşabilir.</p><p>Bu etkileri doğru bir şekilde yönetmeliyiz ki kullanıcı deneyimimiz iyileşsin ve uygulamamızın performansı optimize olsun aksi durumda uygulamamızda donmalar, takılmalar ile karşılaşabiliriz ve bu hiç istemediğimiz bir durumdur. İşte bu noktada <strong>Effect Handlers</strong> diye bahsettiğimiz yapılar ortaya çıkıyor ve Yan etkileri daha efektif bir şekilde yönetmemizi sağlıyor.</p><h4><strong>Effect Handlers Nedir?</strong></h4><p>Compose, Yan etkileri güvenli ve etkili bir şekilde yönetmek için çeşitli Effect handler’lar sunar. Bu yapılar kullanılmazsa, yan etkiler UI thread’i bloke edebilir ve bu durum uygulama performansına ve kullanıcı deneyimine ciddi zarar verir.</p><p><strong>LaunchedEffect</strong></p><p>Composable’ın yaşam döngüsüne bağlı olarak bir kere veya belirli koşullar altında çalışması gereken asenkron işlemler için kullanılır. Composable bir fonksiyondur bu yüzden sadece composable fonksiyon içinde kullanılabilir. Suspend fonksiyon kullanarak yapılacak işlem gerçekleştirilir. Birden fazla key parametresi alabilir. Eğer parametre olarak verilen anahtar değişirse veya Composable ilk kez oluşturulduysa tetiklenir. Coroutine yapısıyla birlikte çalışır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wxtbckQEWPvBd2EkyttFjA.png" /><figcaption>LaunchedEffect fonksiyon yapısı</figcaption></figure><p>LaunchedEffect yapısının daha iyi anlaşılması için Github hesabımda örnek kod paylaştım.</p><p>İncelemek isteyenler için;</p><p><a href="https://github.com/CenkerAydin/SideEffects">GitHub - CenkerAydin/SideEffects</a></p><p><strong>rememberCoroutineScope</strong></p><p>Composable’ın yaşam döngüsüne bağlı olarak bir coroutine scope yaratmak için kullanılır. Yani ilgili composable başka bir ekrana geçiş yaparsa veya recomposition olursa oluşturulan coroutine scope iptal edilir. Bu durum performans optimizasyonuna katkıda bulunur. Eğer coroutine’i bir composable’ın içinde <em>doğrudan</em> değil de, örneğin <strong>bir butonun </strong><strong>onClick bloğunda</strong> başlatmak istenildiğinde, LaunchedEffect yerine rememberCoroutineScope kullanılmalıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dCS-s1VUTtVyMN0Ufy5zxQ.png" /><figcaption>rememberCoroutineScope yapısı</figcaption></figure><p><strong>rememberUpdatedState</strong></p><p>LaunchedEffect içinde verdiğimiz anahtarlar değiştiğinde sürekli olarak tekrar çalışıyordu ama bazen içerisindeki anahtarlar değişse bile coroutine yeniden çalışmasını istemediğimiz durumlar olabilir, bu durumlarda rememberUpdatedState kullanmalıyız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*uRngv8I6R011jPhpMtOicw.png" /><figcaption>rememberUpdatedState yapısı</figcaption></figure><p><strong>DisposableEffect</strong></p><p>Bazı yan etkiler, işi bitince temizlenmesi gerekir. Örneğin:</p><ul><li>Bir <strong>dinleyici (observer)</strong> kaydettiysen, işin bitince onu <strong>kaldırman</strong> gerekir.</li><li>Bir <strong>BroadcastReceiver</strong> eklediysen, kullanmadığında <strong>unregister</strong> etmelisin.</li><li>Bir kaynak açtıysan (örneğin bir socket bağlantısı), çıkarken <strong>kapatmalısın</strong>.</li></ul><p>İşte bu durumlarda oluşturulan kaynağın işi bitince temizlenmesi için DisposableEffect kullanılması gerekir.</p><p><strong>SideEffect</strong></p><p>Compose tarafından <strong>yönetilmeyen</strong> nesnelere veri iletmek veya onları güncellemek için kullanılır. Her başarılı composition/recomposition’dan sonra çalışır. Compose state’ini Compose dışı sistemlere aktarmak için SideEffect kullanılır.</p><h3>Sonuç</h3><p>Jetpack Compose ile çalışırken yan etkilerin doğru şekilde yönetilmesi, uygulamanızın performansı, güvenilirliği ve kullanıcı deneyimi açısından kritik öneme sahiptir. LaunchedEffect, rememberCoroutineScope, rememberUpdatedState, DisposableEffect ve SideEffect gibi araçlar sayesinde Compose’un reaktif doğasına uygun şekilde side effect’leri kontrol altında tutabiliriz. Bu yapıların her biri, belirli senaryolarda daha etkili ve temiz bir çözüm sunarak kodumuzun daha sürdürülebilir olmasını sağlar.<br> Uygulamanız büyüdükçe ve karmaşıklaştıkça, bu yapıları doğru yerde ve doğru şekilde kullanmak, hem hata ayıklamayı kolaylaştırır hem de kullanıcıya daha akıcı bir deneyim sunar. Unutmayın, Compose yalnızca UI çizmekten ibaret değildir; onunla birlikte gelen bu güçlü mekanizmaları tanımak ve etkin şekilde kullanmak da modern Android geliştiricisinin önemli bir yetkinliğidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/384/1*Mm_87bFP2XMjaZBglYbyHQ.gif" /></figure><p>Okuduğunuz için teşekkür ederim. Bir sonraki yazıda görüşmek üzere!</p><p><strong>Kaynaklar</strong></p><ul><li><a href="https://developer.android.com/develop/ui/compose/side-effects#state-effect-use-cases">Side-effects in Compose | Jetpack Compose | Android Developers</a></li><li><a href="https://newsletter.jorgecastillo.dev/p/jetpack-compose-effect-handlers?source=post_page-----971d86adc271---------------------------------------">Jetpack Compose Effect Handlers</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e590a3a2b573" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin Flow ile Asenkron Veri Akışlarını Yönetme]]></title>
            <link>https://medium.com/huawei-developers-tr/kotlin-flow-ile-asenkron-veri-ak%C4%B1%C5%9Flar%C4%B1n%C4%B1-y%C3%B6netme-6dbc133c6e95?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/6dbc133c6e95</guid>
            <category><![CDATA[flow]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Wed, 26 Feb 2025 18:52:39 GMT</pubDate>
            <atom:updated>2025-02-26T18:52:39.239Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BNqREnzWw2aSh1A-" /><figcaption>Kapak resmi</figcaption></figure><h4>Giriş</h4><p>Kotlin Flow, modern Android uygulamalarında veri akışlarını yönetmek için güçlü ve esnek bir yapı sunar. Asenkron işlemleri daha verimli ve okunabilir hale getiren Flow, LiveData ve RxJava’ya alternatif olarak geliştiricilere reaktif programlama avantajları sağlar. Bu yazıda, Flow’un temel kavramlarını, nasıl çalıştığını ve projelerde nasıl kullanılabileceğini ele alacağız. Hazırsanız başlayalım! 🚀</p><h4>Flow Nedir?</h4><p>Türkçeye akış olarak çevirebileceğimiz flow kelimesi Android uygulamalarında bir veri akışını temsil eder ve bu akış, belirli bir zaman diliminde çok sayıda veri öğesi yayınlar. Verileri belirli zamanlarda geldiği durumlarda (veritabanından sorgu gibi asenkron işlemlerde) oldukça faydalıdır. Flow, günümüzde<strong> LiveData</strong> ve <strong>Observable </strong>yapılarına benzer, projenizin gereksinimine göre hangisini kullanacağınıza karar vermelisiniz.</p><p>Kotlin <strong>Coroutines</strong> kütüphanesinin bir parçasıdır ve veri akışlarını asenkron bir şekilde yönetmek için kullanılır.</p><p>Bir akış (flow), bir dizi değer üreten bir Iterator’a çok benzerdir, ancak değerleri asenkron olarak üretmek ve tüketmek için <strong>suspend</strong> fonksiyon kullanır. Bu, örneğin, akışın ana thread’i bloke etmeden bir sonraki değeri üretmek için güvenli bir şekilde ağ isteği yapabileceği anlamına gelir.</p><h4><strong>Flow Oluşturma</strong></h4><p>Dokümantasyonda flow oluştururken <a href="https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/flow.html">flow builder</a> kullanmamız önerilmiş. O yüzden onu kullanarak basit bir flow oluşturma örneği yapacağım.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/39195650a8ab5dc64cf93a91cf920da2/href">https://medium.com/media/39195650a8ab5dc64cf93a91cf920da2/href</a></iframe><p>Örnekte <strong>temperatureFlow</strong> fonksiyonu içinde her saniye rastgele güncellenen sıcaklık değerlerini alan bir flow oluşturduk ve <strong>main</strong> fonksiyonu içinde gelen verileri alarak ekrana yazdırıyoruz.</p><p>Kodu detaylı bir şekilde incelediğimizde 2. satırda yazdığımız fonksiyonun geri dönüş tipinin Flow&lt;Int&gt; olduğunu görüyoruz ve <strong>flow {}</strong>arasında yeni bir flow oluşturma işlemini yapıyoruz. <strong>emit</strong> fonksiyonunu kullanarak akışa yeni bir veri ekliyoruz. <strong>delay</strong> fonksiyonu ile emit ile göndereceğimiz verilerin kaç saniye aralıkla gönderileceğini söylüyoruz. Flow’ların asenkron olarak çalıştığını ve coroutines kütüphanesinin bir parçası olduğunu söylemiştik, main fonksiyon ise senkron yapıdadır. Bu sebeple main fonksiyonu içinde temperatureFlow fonksiyonunu <strong>runBlocking</strong> blokları arasında çağırmamız gerekiyor. runBlocking çağrıldığı yerde bir <strong>coroutines</strong> başlatılmasını sağlar. <strong>collect</strong> fonksiyonu ile akıştaki verileri dinleyerek ekrana yazdırma işlemini yapıyoruz.</p><ol><li><strong>flow {}</strong> → Yeni bir Flow oluşturduk.</li><li><strong>emit(value)</strong> → Her saniye yeni bir sıcaklık değeri yaydık.</li><li><strong>delay(1000)</strong> → Akışı her saniye güncelleyerek asenkron çalışmasını sağladık.</li><li><strong>collect {}</strong> → Yayınlanan verileri dinleyip ekrana yazdırdık.</li></ol><h4>Flow Operatörleri</h4><p>Flow kullanırken veriyi istediğimiz gibi işleyebilmek için çeşitli operatörlerden faydalanabiliriz. Bu operatörler, bir veri akışını dönüştürmek, filtrelemek veya farklı şekillerde işlemek için kullanılır.</p><ol><li><strong>map : </strong>Flow içindeki her bir veriyi belirli bir işleme tabi tutarak dönüştürmek için kullanılır.</li></ol><pre>fun numberFlow(): Flow&lt;Int&gt; = flow {<br>    for (i in 1..5) {<br>        emit(i)<br>    }<br>}<br><br>fun main() = runBlocking {<br>    numberFlow()<br>      .map { number -&gt; number * 2 } // Akıştaki tüm veriyi 2 ile çarpıyoruz.<br>      .collect { value -&gt;<br>        println(&quot;Received: $value&quot;)<br>      }<br>}<br><br>//Output <br>Received: 2<br>Received: 4<br>Received: 6<br>Received: 8<br>Received: 10</pre><p>2<strong>. filter</strong> : Belirli bir koşulu sağlayan verileri akış içinde tutmak için kullanılır.</p><pre>fun numberFlow(): Flow&lt;Int&gt; = flow {<br>    for (i in 1..5) {<br>        emit(i)<br>    }<br>}<br><br>fun main() = runBlocking {<br>    numberFlow()<br>        .filter { it %2 == 0 } //Sadece çift rakamları alıyoruz.<br>        .collect { value -&gt;<br>        println(&quot;Received: $value&quot;)<br>        }<br>}</pre><p>3. <strong>collect</strong> : Flow’dan gelen verileri almak ve kullanmak için çağrılan terminal operatörüdür.</p><p>En çok kullanılan operatörlerden bahsettim ama dilerseniz dokümantasyon üzerinden daha fazla operatörlere göz atabilirsiniz.</p><h4>StateFlow ve SharedFlow Nedir?</h4><p>Kotlin Flow <strong>cold </strong>(Soğuk)<strong> </strong>bir akış türüdür ve bu sebepten dolayı sadece collect fonksiyonu kullanıldığında çalışır. Yaptığımız projelerde bu şekilde kullanımı çok az kullanıyoruz. Genellikle UI bileşenlerine sürekli güncellenen veri gönderiyoruz. Bu gönderimi ise StateFlow ve SharedFlow ile yapıyoruz. Bu iki yapıyı özellikle MVVM mimari yapısında veri akışını yönetmek için kullanıyoruz.</p><blockquote><strong>StateFlow</strong></blockquote><ul><li><strong>Hot</strong> (Sıcak) bir akış türüdür, her zaman aktif ve günceldir.</li><li>Initial value verilmesi gerekir.</li><li><strong>Son yayınlanan değeri saklar.</strong></li><li>Yapı olarak LiveData’ya benzer.</li></ul><p>Aşağıdaki durumlardan birine ihtiyacınız varsa StateFlow kullanılması daha uygundur.</p><ul><li>UI durumu (state) yönetimi için</li><li>En son değeri saklamak istiyorsan</li><li>Birden fazla abone (collect) olabilir ve her biri son değeri almalıysa</li><li>LiveData alternatifi olarak kullanılacaksa</li></ul><blockquote><strong>SharedFlow</strong></blockquote><ul><li>Hot (Sıcak) bir akış türüdür.</li><li>Initial value verilmesine gerek yoktur.</li><li>En son değeri saklamaz.</li><li><strong>Birden fazla aboneyle veri paylaşabilir</strong>.</li></ul><p>Tek seferlik olaylar için (Toasts, Navigation veya API Error mesajları) gibi durumlarda SharedFlow kullanılabilir.</p><p>StateFlow kullanarak Mvvm mimarisinde, Compose ile yazdığım basit bir sayaç uygulamasını incelemek isterseniz <a href="https://github.com/CenkerAydin/FlowExample">buraya</a> tıklayarak bakabilirsiniz.</p><h4>Sonuç</h4><p>Kotlin Flow, modern Android uygulamalarında asenkron veri akışlarını yönetmek için güçlü ve esnek bir çözüm sunar. Yapısal olarak <strong>coroutine</strong> tabanlı olması, performansı artırırken kodun daha okunabilir ve yönetilebilir olmasını sağlar. Veri akışlarını daha verimli işlemek, gecikmeleri yönetmek ve reaktif programlamayı daha kolay hale getirmek için Flow’un sunduğu operatörler ve özellikler büyük avantajlar sağlar. Doğru kullanıldığında, Kotlin Flow uygulamalarınızın daha akıcı, güvenilir ve ölçeklenebilir olmasına katkı sağlar. Akışların gücünü keşfederek projelerinize değer katmaya devam edin! 🚀</p><p>Okuduğunuz için teşekkür ederim. Bir sonraki yazıda görüşmek üzere!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*1j9TXSuIhkkObUi5.gif" /><figcaption><a href="https://giphy.com/">Referans</a></figcaption></figure><h4><strong><em>Referanslar</em></strong></h4><ul><li><a href="https://developer.android.com/kotlin/flow">Kotlin flows on Android | Android Developers</a></li><li><a href="https://medium.com/simform-engineering/introduction-to-kotlin-flow-f425b5a839f">Introduction to Kotlin Flow</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dbc133c6e95" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-developers-tr/kotlin-flow-ile-asenkron-veri-ak%C4%B1%C5%9Flar%C4%B1n%C4%B1-y%C3%B6netme-6dbc133c6e95">Kotlin Flow ile Asenkron Veri Akışlarını Yönetme</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[Android Uygulamalarda Testin İncelikleri]]></title>
            <link>https://medium.com/huawei-developers-tr/android-uygulamalarda-testin-i%CC%87ncelikleri-137f9c6a5654?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/137f9c6a5654</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[android-test]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Sun, 12 Jan 2025 09:30:49 GMT</pubDate>
            <atom:updated>2025-01-12T09:30:49.344Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Uygulamalarda Test Yazmanın İncelikleri</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZicIjN4e4G6-SNIX" /><figcaption><a href="https://chatgpt.com/">Referans</a></figcaption></figure><h4><strong>Giriş</strong></h4><p>Mobil uygulama geliştirme sürecinin vazgeçilmez bir parçası olan test yazma, uygulamaların sorunsuz ve beklenen şekilde çalışmasını sağlamak için kritik bir rol oynar. Android platformunda test geliştirme, uygulama geliştiricilere hem kod kalitesini yükseltme hem de hata oranını düşürme konusunda önemli avantajlar sunar. Ayrıca, bu süreç geliştirmenin daha verimli hale gelmesini ve yazılan kodun uzun vadede daha kolay bakımını sağlar. Test yazmak, sadece uygulamanın doğruluğunu değil, aynı zamanda kullanıcı deneyimini de iyileştirmenin temel yollarından biridir. Çayınızı veya kahvenizi aldıysanız hadi başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*mlSQGiJIc6iMwQUd.gif" /><figcaption><a href="https://giphy.com/gifs/BritanniaOnEpix-begin-the-time-is-now-lets-Pmv6m86yGQCjkLjmqx">Referans</a></figcaption></figure><h4><strong><em>Test Yazmak Nedir?</em></strong></h4><p>Test yazmak, bir yazılımın farklı bileşenlerini sistematik olarak incelemek ve bu bileşenlerin doğru çalışıp çalışmadığını belirlemek amacıyla çeşitli senaryolar oluşturmak anlamına gelir. Yazılım testi, yazılımın istenilen gereksinimlere uygun şekilde çalıştığını ve hatalardan arınmış olduğunu garanti etmeye yardımcı olur.</p><h4><strong><em>Test yazmak neden Önemlidir?</em></strong></h4><p>Test yazmanın faydaları:</p><ul><li><strong>Hataları Erken Tespit Etme:</strong> Geliştirme sürecinde hataları erken fark ederek zaman ve maliyet tasarrufu sağlar.</li><li><strong>Kod Kalitesini Artırma:</strong> Testler, daha temiz ve bakımı kolay bir kod tabanı oluşturmanıza yardımcı olur.</li><li><strong>Güvenilirlik:</strong> Uygulamanın çalışma durumunu garanti altına alarak, kullanıcı deneyimini geliştirir.</li><li><strong>Bakım Kolaylığı:</strong> Kod tabanınızdaki değişikliklerin mevcut işlevleri bozup bozmadığını kontrol etmek için testler hayati önem taşır.</li></ul><h3><strong><em>Manuel Test vs Automated Test</em></strong></h3><p>Yazılım şirketleri Manuel ve Automated Test stratejilerini kullanır. <strong>Manuel test</strong>, test senaryolarının bir test uzmanı tarafından kontrol edilmesine dayanır. Test uzmanı farklı cihaz veya emülator üzerinden uygulamayı açarak farklı senaryolarda uygulamada bir hata veya eksiklik gözlenip gözlenmediğini kontrol eder. İnsan tarafından yapıldığı için bir otomasyon aracına ihtiyaç duyulmaz. Test yapan kişiye bağlı olduğu için bazı hatalar veya eksiklikler gözden kaçabilir. <strong>Automated test</strong>, test senaryolarının kontrolü test aracı sayesinde gerçekleşir. Test senaryoları kod yazılarak oluşturulur ve belli bir komutla otomatik olarak çalışır, bu sayede daha hızlı kontrol yapılmış olur. İnsan tarafından yapılmadığı için daha az hata gözlenir.</p><p>Manuel ve Automated Test karşılaştırmasını aşağıdaki hazırladığım tablodan inceleyebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1pOn4AwB4LW3oVhaUbOPyQ.png" /></figure><h4><strong>Android Test Piramiti</strong></h4><p>Android test piramidi, yazılım geliştirme sürecinde testlerin nasıl organize edilmesi gerektiğini görselleştiren bir çerçevedir. Piramit, testlerin farklı seviyelerini ve her seviyede hangi tür testlerin yapılması gerektiğini ifade eder. Bu yaklaşım, uygulama geliştirme sürecinde yüksek kaliteyi, hızlı geri bildirim döngülerini ve düşük maliyeti sağlamayı amaçlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0YzZ1JLT3DFiq0mESONkkA.png" /><figcaption><a href="https://proandroiddev.com/a-guide-to-test-pyramid-in-android-part-1-8b3b42d0a150">Referans</a></figcaption></figure><h4><strong>Unit Test (Birim Testleri)</strong></h4><p>Birim testleri, uygulamanın en küçük birimlerini, genellikle tek bir sınıf veya metot seviyesinde test eder. Amaç, kodun doğru çalıştığından emin olmaktır. Yaygın olarak kullanılır. İzole edilmiş testlerdir. Kolay yazılır ve bakim maliyeti düşüktür. Yazılırken <strong>JUnit</strong> ve <strong>Mockito</strong> gibi test araçları kullanılabilir. Test piramidinin tabanında bulunur ve en geniş kısmı oluşturur, tüm testlerin %70-%80&#39;i bu katmanda bulunmalıdır.</p><pre><br>class PasswordValidator {<br><br>    fun isValid(password: String?): Boolean {<br>        if (password.isNullOrEmpty()) {<br>            return false<br>        }<br>        if (password.length &lt; 8) {<br>            return false<br>        }<br>        if (!password.any { it.isDigit() }) { // Şifre bir rakam içermeli<br>            return false<br>        }<br>        return true<br>    }<br>}<br><br>class PasswordValidatorTest {<br><br>    private val validator = PasswordValidator()<br><br>    @Test<br>    fun `password is valid`() {<br>        // Geçerli bir şifre<br>        assertTrue(validator.isValid(&quot;Password123&quot;))<br>    }<br><br>    @Test<br>    fun `password is too short`() {<br>        // Şifre 8 karakterden kısa<br>        assertFalse(validator.isValid(&quot;Pass12&quot;))<br>    }<br><br>    @Test<br>    fun `password without numbers`() {<br>        // Şifre rakam içermiyor<br>        assertFalse(validator.isValid(&quot;Password&quot;))<br>    }<br><br>    @Test<br>    fun `password is null`() {<br>        // Şifre null<br>        assertFalse(validator.isValid(null))<br>    }<br><br>    @Test<br>    fun `password is empty`() {<br>        // Şifre boş string<br>        assertFalse(validator.isValid(&quot;&quot;))<br>    }<br>}</pre><p>PasswordValidatorTest sınıfındaki kodu çalıştırdığımızda aşağıdaki görseldeki gözüktüğü gibi çıktı alacağız ve bu 5 testimizinde testten geçtiğini gösteriyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-YEUFP99AVHunarkspn_w.png" /></figure><p>Bu şekilde basit ve küçük seviyedeki fonksiyonları veya sınıfları kontrol etmek için yazdığımız testlere <strong>Unit Test</strong> diyoruz.</p><h4>Integration Test (Entegrasyon Testleri)</h4><p>Integration Test, adından anlaşılacağı üzere farklı modüllerin birlikte doğru bir şekilde çalışıp çalışmadığını kontrol etmek için kullanılır. <strong>Robolectric </strong>test aracı kullanılır. Gerçek dünya senaryolarını simüle eder, Unit Teste göre daha yavaş çalışır ama daha kapsamlıdır. Test piramidinin ortasında yer alır ve testlerin yaklaşık %15-%20&#39;si bu katmanda bulunmalıdır.</p><h4>UI Test (Kullanıcı Arayüzü Testleri)</h4><p>UI testleri, uygulamanın kullanıcı arayüzünün (UI) ve kullanıcı deneyiminin (UX) doğru çalışıp çalışmadığını kontrol eder. Amaç, kullanıcıların uygulamayla sorunsuz etkileşim kurduğundan emin olmaktır. Espresso, Robotium, UI Automator gibi test araçları kullanılabilir. Buton tıklama, ekran kaydırma , metin girme gibi kullanıcı davranışlarını taklit eder. En yavaş ve en maliyetli testlerdir. Test piramidinin en üstünde yer alır ve testlerin yaklaşık %5–10&#39;u bu katmanda bulunmalıdır.</p><p>!!! Bazen bu test piramidi yanlış uygulanır ve bir ters piramit şekline dönüşerek <strong>Anti-pattern</strong> olur. Test piramidi şu şekilde uygulanırsa yanlış uygulanmış olur:</p><ul><li>Çok fazla UI testi yazılır.</li><li>Az sayıda birim testi ve entegrasyon testi vardır.</li><li>Testlerin çalıştırılması uzun sürer ve CI/CD süreçlerini yavaşlatır.</li><li>Testlerin bakım maliyeti yükselir.</li></ul><p>Bu durumdan kaçınmak için, piramidin dengeli bir şekilde oluşturulması gereklidir.</p><h3><strong>Instrumented ve Local Testler</strong></h3><p>Android Studio’daki Android alanının altında androidTest ve test olmak üzere 2 tane ayrı test paketi vardır. androidTest kısmına instrumented test, normal test kısmına ise genel olarak non instrumented veya local test denir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*fWzTlIlV1ENh4qGLhhkEeQ.png" /></figure><h4><strong><em>Instrumented Test</em></strong></h4><p>Instrumented Test, uygulamanın <strong>gerçek bir cihazda veya bir emülatörde çalışırken</strong> test edilmesine denir. Bu testler uygulamanın Android framework’üyle etkileşimini inceler ve cihaz özelliklerini kullanır. Genellikle androidTest altında yazılır. Büyük ve karmaşık testlerdir ve bu yüzden yavaş çalışır.</p><h4><strong>Local Test</strong></h4><p>Local Test, uygulamanın Android cihaz veya emülatörü dışında, genellikle bilgisayar ortamında test edilmesine denir. Bu testler Java Virtual Machine (JVM) üzerinde çalışır. Uygulamanın iş mantığı, algoritmalar ve diğer bağımsız kodların doğruluğunu hızlı bir şekilde test etme amacıyla yazılır. Genellikle test altında yazılır ve JUnit gibi araçlar kullanılır.</p><p>Instrumented ve Local Test arasındaki farkları hazırladığım tablodan inceleyebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0LOQDAbi-9G56-yxv008LQ.png" /></figure><p><strong>Test Driven Development (TDD)</strong></p><p><strong>Test Driven Development (TDD)</strong>, yani türkçeye <strong>Test Güdümlü Geliştirme </strong>olarak çevirebileceğimiz terim, yazılım geliştirme sürecinde <strong>testlerin yazılım kodundan önce oluşturulmasını</strong> öngören bir yazılım geliştirme yaklaşımıdır. TDD, hataların erken tespit edilmesine yardımcı olur ve daha güvenilir bir kod tabanı oluşturmayı hedefler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9K4jzdxijJFgupgopOJ7yg.png" /><figcaption><a href="https://www.zealousys.com/blog/what-is-test-driven-development/">Referans</a></figcaption></figure><p>TDD genellike 5 adımdan oluşur. Bunlar;</p><p><strong>1. Başarısız bir test yaz (Red Aşaması):</strong></p><p>Uygulamada olmasını düşündüğünüz bir özellik belirleyerek henüz yazılmamış olan kodun beklentinizi test edecek testi oluşturun ve testi çalıştırın. Bu test henüz kod yazılmadığı için başarısız olacaktır.</p><p><strong>2. Testi Geçmek İçin En Basit Kodu Yaz (Green Aşaması):</strong></p><p>İlk adımda yazdığınız testin geçmesini sağlayacak basit seviyede kodu yazın. Bu aşamada kodun temiz ve mükemmel olmasına gerek yoktur. Bu aşamadaki amaç testi başarılı bir şekilde geçmektir.</p><p><strong>3. Kodu İyileştir (Refactor Aşaması):</strong></p><p>Test geçtikten sonra kodun daha okunabilir ve anlaşılabilir olması için kodu gözden geçirip gerekli iyileştirmeleri yapın.</p><p><strong>4. Tüm Testleri Çalıştır (Yeniden Green Aşaması):</strong></p><p>Yeni bir özellik eklemeden veya mevcut kodu değiştirmeden tüm testleri çalıştırın. Eğer herhangi bir test çalışmazsa onu düzeltin.</p><p><strong>5. Süreci Tekrarlayın (Red-Green-Refactor Döngüsü):</strong></p><p>Uygulamaya eklemek istediğiniz yeni özellik veya değişiklikler için bu adımları tekrarlayın.</p><p>TDD , uzun vadede bakımı kolay ve daha az hatalı yazılımlar geliştirmek için oldukça güçlü bir yaklaşım sunmaktadır.</p><h3><strong>Sonuç</strong></h3><p>Android uygulamalarında test süreçleri, <strong>kaliteli</strong> ve <strong>sürdürülebilir</strong> yazılım geliştirme için kritik bir rol oynamaktadır. <strong>Local testler</strong> ile iş mantığının doğruluğu hızlı bir şekilde kontrol edilirken,<strong> instrumented testler</strong> sayesinde uygulamanın gerçek cihazlarda nasıl davrandığı detaylı bir şekilde incelenir. Ayrıca,<strong> Test Driven Development (TDD)</strong> gibi yaklaşımlar, hem hataların erken tespit edilmesini sağlar hem de geliştiricilere daha sistematik bir çalışma disiplini kazandırır. Android test araçlarının etkin bir şekilde kullanılması, hem geliştirici ekiplerin hem de son kullanıcıların daha <strong>stabil</strong> ve <strong>güvenilir</strong> uygulamalarla buluşmasını mümkün kılar. Test süreçlerinin yazılım geliştirme döngüsünün vazgeçilmez bir parçası olduğu unutulmamalıdır.</p><p>Okuduğunuz için teşekkür ederim. Bir sonraki yazıda görüşmek üzere!</p><h3><strong>Referanslar</strong></h3><ul><li><a href="https://www.testrail.com/blog/manual-vs-automated-testing/">Manual Testing vs Automated Testing: Key Differences - TestRail</a></li><li><a href="https://developer.android.com/training/testing">Test apps on Android | Android Developers</a></li><li><a href="https://medium.com/@nerobianchi/tdd-nedir-965c1a26e68f">TDD nedir?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=137f9c6a5654" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-developers-tr/android-uygulamalarda-testin-i%CC%87ncelikleri-137f9c6a5654">Android Uygulamalarda Testin İncelikleri</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[Kotlin ile SharedPreferences Kullanımı]]></title>
            <link>https://medium.com/huawei-developers-tr/kotlin-ile-sharedpreferences-kullan%C4%B1m%C4%B1-c0784201b51c?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0784201b51c</guid>
            <category><![CDATA[sharedpreferences]]></category>
            <category><![CDATA[türkçe]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Wed, 06 Nov 2024 13:31:16 GMT</pubDate>
            <atom:updated>2024-11-06T13:31:16.540Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T8SMhgh7N-VD4fPBzmxLvQ.jpeg" /><figcaption><a href="https://unsplash.com/">Referans</a></figcaption></figure><h3><strong>Giriş</strong></h3><p>Merhabalar. Android uygulama geliştirirken verileri tutmamıza yardımcı olan birçok araç vardır, bugün bu araçlardan biri olan SharedPreferences konusunu ele alacağım. Keyifli okumalar diliyorum!</p><blockquote><strong>SharedPreferences Nedir?</strong></blockquote><p>SharedPreferences, Android uygulamalarında <strong>küçük veri kümelerini </strong>saklamak için kullanılan basit ve hızlı veri depolama yöntemidir. Bu yöntem ile Android’de kullanıcı tercihleri ve ayarları gibi kalıcı verileri pratik bir şekilde saklayabiliriz. SharedPreferences, <strong>key-value ( anahtar-değer)</strong> yapısıyla kolay bir kullanım sunar. Küçük verilerin saklanması için bir veritabanı oluşturup orada tutmak maliyetli bir kullanıma yol açabilir bu yüzden SharedPreferences kullanmamız daha uygun olacaktır.</p><blockquote><strong>SharedPreferences Oluşturma</strong></blockquote><p>SharedPreferences oluşturmanın iki yolu vardır. Bunlar <strong>getSharedPreferences()</strong> ve <strong>getPreferences()</strong> fonksiyonlarıdır.</p><ul><li>getSharedPreferences() fonksiyonu ile uygulama içerisinde birden fazla SharedPreferences dosyası oluşturmamızı sağlar. Bu fonksiyon iki tane parametreye sahiptir. İlk parametre String türünde, ikinci parametre ise int türündedir. İlk parametreye dosyanın ismini veriyoruz, ikinci parametreye ise dosyanın hangi mode durumunda olacağını belirtiyoruz. Bu yöntemi herhangi bir Context üzerinden çağırabilirsiniz; bu, hem Activity&#39;ler hem de Fragment&#39;ler gibi diğer Context türleri için geçerlidir.</li></ul><pre>val sharedPreferences = getSharedPreferences(<br>&quot;MyPreferences&quot;, <br>Context.MODE_PRIVATE<br>)</pre><p>Yukarıdaki kod bloğunu incelediğinizde nasıl bir yapıya sahip olduğunu daha iyi anlayacaksınız. Burada mode durumu MODE_PRIVATE en çok kullanılan mode durumlarından biridir. Bu mode sayesinde oluşturduğumuz dosyaya sadece uygulama içerisinde erişim izni vardır, başka bir şekilde erişilemez olacaktır.</p><ul><li>getPreferences() fonksiyonu , yalnızca bir Activity içinde kullanılmak üzere tasarlanmıştır ve o Activity için varsayılan bir Shared Preferences dosyası döndürür. Bu dosya, Activity&#39;nin yaşam döngüsüne bağlıdır. Genellikle, belirli bir Activity ile ilişkili ayarları saklamak için uygundur.</li></ul><pre>val preferences = getPreferences(Context.MODE_PRIVATE)</pre><p>Bu yöntemlerin her biri, uygulamanın ihtiyaçlarına ve tasarımına göre farklı avantajlar sunar. getSharedPreferences() daha esnek bir yapı sağlarken, getPreferences() daha basit bir kullanım sunar ve tek bir Activity için yeterli olabilir.</p><blockquote><strong><em>SharedPreferences ile veri kaydetme</em></strong></blockquote><p>Yukarıdaki getSharedPreferences() fonksiyonu ile SharedPreferences dosyamızı oluşturduğumuzu varsayalım. SharedPreferences üzerinden veri okuma, silme kaydetme gibi işlemler yapabilmek için SharedPreferences.Editör nesnesini kullanmamız gerekiyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mtjpz4YSHlt49O8yzV770g.png" /><figcaption>SharedPreferences.Editör fonksiyonları</figcaption></figure><p>Görselde gördüğünüz gibi Boolean, Float, Int, Long ve String türünde değerleri kolaylıkla dosyamıza kaydedebiliriz. Merak edenler için bütün <a href="https://developer.android.com/reference/android/content/SharedPreferences.Editor">methodlar.</a></p><p>Şimdi SharedPreferences dosyamıza veri kaydetme işlemini görelim.</p><pre>val editor = sharedPreferences.edit() <br>editor.putString(&quot;name&quot;, &quot;Cenker Aydın&quot;) <br>editor.putInt(&quot;age&quot;, 22)  <br>editor.apply()</pre><p>SharedPreferences kullanarak kolay ve hızlı bir şekilde veri kaydedebilirsiniz.</p><blockquote><strong><em>SharedPreferences ile veri okuma</em></strong></blockquote><p>Kaydettiğimiz verileri okumak için ilgili key ( anahtar) üzerinden verimize erişebiliriz.</p><pre>val name= sharedPreferences.getString(&quot;name&quot;, &quot;&quot;)  // &quot;&quot; varsayılan değer.<br>val age = sharedPreferences.getInt(&quot;age&quot;, 0)  // 0 varsayılan değer.</pre><p>Buradaki kullanımda varsayılan değer verme sebebimiz key üzerinden ulaşmaya çalıştığımız veri eğer kaydedilmemişse varsayılan değer dönecektir, mesela age anahtarında herhangi bir değer kaydedilmedi diye düşünelim varsayılan değeri yani 0 döndürecektir.</p><blockquote><strong><em>SharedPreferences ile veri silme</em></strong></blockquote><p>Kaydettiğimiz verileri silmek istediğimizde editor nesnesi üzerinden <strong>remove() </strong>fonksiyonunu kullanabiliriz. Bu fonksiyonu kullanırken parametre olarak silmek istediğimiz verinin key (anahtar) değerini vermemiz gerekiyor.</p><pre>editor.remove(&quot;name&quot;) <br>editor.apply() //Bu şekilde istediğimiz veriyi siliyoruz.</pre><p>Tek bir veri yerine bütün verileri silmek istediğimiz editor nesnesi üzerinden clear() fonksiyonunu kullanabiliriz.</p><pre>editor.clear()<br>editor.apply() //Tüm veriyi siliyoruz.</pre><blockquote><strong><em>SharedPreferences Avantajları ve Dezavantajları</em></strong></blockquote><h4><strong><em>Avantajlar</em></strong></h4><ul><li><strong>Kolay kullanım:</strong> SharedPreferences, key-value çiftleri ile veri saklama işlemini çok basit bir hale getirir.</li><li><strong>Kullanıcı Özelleştirmesi</strong>: Uygulama kullanıcılarının tercihlerini saklayarak, onlara kişiselleştirilmiş bir deneyim sunmayı sağlar.</li><li><strong>Kalıcı Veri</strong>: Veriler, uygulama kapatıldığında veya cihaz yeniden başlatıldığında bile kalıcıdır.</li></ul><h4><strong>Dezavantajlar</strong></h4><ul><li><strong>Sınırlı Veri Büyüklüğü</strong>: SharedPreferences, yalnızca küçük veri kümesi (genellikle birkaç kilobayt) için uygundur. Büyük veri setleri için verimli değildir. Büyük veri setleri için daha kapsamlı veri saklama araçları kullanılmalıdır.</li><li><strong>Veri Türü Sınırlamaları</strong>: Sadece temel veri türlerini (String, int, boolean, float, long) destekler. Daha karmaşık veri yapıları (örneğin, nesneler veya listeler) için uygun değildir.</li><li><strong>Güvenlik açığı</strong>: SharedPreferences verileri, uygulamanın veri dizininde düz metin olarak saklanır, bu da kötü niyetli bir kullanıcının verilere erişmesine olanak tanıyabilir. Özel verilerin saklanması gereken durumlarda daha güvenli veri saklama araçları kullanılmalıdır.</li></ul><blockquote><strong>Sonuç</strong></blockquote><p>SharedPreferences uygulama içinde kullanıcı ayarları ve basit verileri saklamak için verimli bir araçtır. Kolay kullanılması, veri erişiminin hızlı olması, kullanıcı deneyimini kişiselleştirilmeye yardımcı olması gibi avantajları sayesinde günümüzde birçok uygulamada tercih edilmektedir. Ancak, küçük boyutlu veriler için uygun olması, güvenlik endişeleri gibi konular göz önünde bulundurulduğunda yazılan uygulamanın içeriği ve isteklerine bakılarak SharedPreferences kullanılıp kullanılmayacağına karar verilmelidir.</p><p>Okuduğunuz için teşekkür ederim. Bir sonraki yazılarda görüşmek üzere!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*lItp0II_CzJ1TA1B.gif" /><figcaption><a href="https://giphy.com/gifs/thanks-thank-you-da-best-3o6ozm2sJ102JdumVq">Referans</a></figcaption></figure><blockquote><strong><em>Referanslar</em></strong></blockquote><p><a href="https://developer.android.com/training/data-storage/shared-preferences">Save simple data with SharedPreferences | Android Developers</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0784201b51c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/huawei-developers-tr/kotlin-ile-sharedpreferences-kullan%C4%B1m%C4%B1-c0784201b51c">Kotlin ile SharedPreferences Kullanımı</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[Hilt: Android’de Modern ve Kolay Bağımlılık Enjeksiyonu]]></title>
            <link>https://medium.com/@cenkeraydin14/hilt-androidde-modern-ve-kolay-ba%C4%9F%C4%B1ml%C4%B1l%C4%B1k-enjeksiyonu-3478a0cfcf25?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/3478a0cfcf25</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Tue, 03 Sep 2024 09:11:56 GMT</pubDate>
            <atom:updated>2025-01-16T12:53:28.618Z</atom:updated>
            <content:encoded><![CDATA[<p>Herkese yeniden merhabalar. Bugün sizlerle birlikte Dependency Injection kütüphanesi olan Hilt konusunu el alacağız. Bir önceki yazımda Dependency Injection konusundan bahsetmiştim, eğer okumadıysanız o yazıyı okumanızı tavsiye ederim. <a href="https://medium.com/stackademic/dependency-injection-di-2d1e67c92bc8">Dependency Injection yazısı.</a> Keyifli okumalar!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/525/0*TrxHi-B4DrP-16SK.png" /></figure><h4>Hilt vs Koin</h4><p>Hilt detaylarına geçmeden önce bir diğer Dependency Injection kütüphanesi olan Koin ile kıyaslamasını yapmak istiyorum. <strong>Burada hangisi iyi hangisi kötü olarak değil, birbirlerine göre avantajlarından ve dezavantajlarından bahsedeceğiz. Hangi kütüphaneyi kullanacağınız projenizin htiyaçlarına göre farklılık gösterecektir.</strong></p><ul><li>Hilt, generate edilen classlar ve anotasyon yapısıyla çalışır. Koin ise DSL (Domain Specific Language) yapısıyla çalışır.</li><li>Hilt compile time güvenliği sağlarken Koin runtime güvenliği sağlar. Hilt derleme sırasında bağımlılıkların çözülmesi ve hataların tespit edilmesini sağlar. Koin runtime sırasında bağımlılıkları çözer.</li><li>Hilt kullanılan projelerin derlenmesi daha uzun sürebilir çünkü di sunarken generate edilen classları kullanır. Koin projelerin derlenme süresi daha kısa sürebilir çünkü bağımlılıkları runtime’da çözer.</li><li>Hilt, Google tarafından geliştirilmiş bir kütüphane olduğu için Android ekosistemi ile derin bir entegrasyona sahiptir. Activity, ViewModel gibi temel Android bileşenleriyle uyumlu ve sorunsuz çalışır.</li><li>Hilt, anotasyon yapısı kullandığı için ilk öğrenimde yapıları anlamakta zorlanılabilir, Koin bu konuda daha basit ve daha hızlı öğrenilebilir.</li><li>Hilt, anotasyonlarla birlikte generate edilmesi gereken yapıları otomatik generate ederek geliştiriciyi boilerplate kod yapısından kurtarır.</li></ul><p>Her iki kütüphane de belirli kullanım senaryolarında avantajlar sunar, bu yüzden proje gereksinimlerinize en uygun olanı seçmek önemlidir.</p><p>Hilt vs Koin farklarından kısaca bahsettikten sonra ana konumuz olan Hilt’e geçebiliriz.</p><h4>Nedir bu Hilt?</h4><p>Hilt, Google tarafından Android uygulamalardaki bağımlılıkları azaltmayı ve daha esnek yönetmeyi amaçlayan bir Dependency Injection kütüphanesidir. Dagger kütüphanesi üzerine inşa edilmiştir ve dependency injection işlemlerini daha kolay ve daha verimli hale getirir.</p><p>Dagger güçlü bir DI kütüphanesi olmasına rağmen yapılandırılması, anlaşılması ve kullanımı oldukça karmaşık olduğu için onun yerine Dagger avantajlarını kullanan ama Dagger kütüphanesine göre daha kolay ve anlaşılabilir Hilt yerini almıştır.</p><h4>Hilt kullanımı</h4><p>Projelerimizde Hilt kullanabilmek için öncelikle Hilt kütüphanesini projemize eklemeliyiz.</p><p>Öncelikle proje dizininde build.gradle dosyasına aşağıdaki bloğu eklememiz gerekiyor.</p><pre>plugins {<br>  ...<br>  id &#39;com.google.dagger.hilt.android&#39; version &#39;2.48&#39; apply false<br>}</pre><p>Ondan sonra app dizinindeki build.gradle dosyasına aşağıdaki blokları eklememiz gerekiyor.</p><pre>...<br>plugins {<br>  id &#39;kotlin-kapt&#39;<br>  id &#39;com.google.dagger.hilt.android&#39;<br>}<br><br>android {<br>  ...<br>}<br><br>dependencies {<br>  implementation &quot;com.google.dagger:hilt-android:2.48&quot;<br>  kapt &quot;com.google.dagger:hilt-compiler:2.48&quot;<br>}<br><br>// Allow references to generated code<br>kapt {<br>  correctErrorTypes true<br>}</pre><p>Bunları ekledikten sonra Hilt kütüphanesi projemizde kullanılmaya hazır hale getiriyoruz.</p><p>Şimdi anotasyonlar üzerinden ilerleyerek Hilt’in detaylarına inelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*oRqM-BCvYT_udYXZ.gif" /></figure><blockquote><strong><em>HiltAndroidApp</em></strong></blockquote><pre>package com.cenkeraydin.hiltmedium.di<br><br>import android.app.Application<br>import dagger.hilt.android.HiltAndroidApp<br><br>@HiltAndroidApp<br>class App : Application() {<br>}</pre><p>Application sınıfını miras alan bir class yazıyoruz ve @HiltAndroidApp anotasyonunu ekliyoruz. Uygulama sınıfına eklenen bu anotasyon, Hilt’in uygulama boyunca bağımlılıkları yönetmesini sağlar. Hilt’in bağımlılık grafiğini uygulama yaşam döngüsü boyunca oluşturmasına olanak tanır.</p><p>Manifest dosyasına App classını tanımlıyoruz.</p><pre> &lt;application<br>        android:name=&quot;.di.App&quot;<br>        ...<br> &lt;/application&gt;</pre><blockquote><strong>AndroidEntryPoint</strong></blockquote><p>Bu anotasyon, Hilt’in Android bileşenlerine (Activity, Fragment, View, Service, BroadcastReceiver) bağımlılık enjekte etmesini sağlar. Hilt’in bağımlılık grafiğinden gerekli nesneleri otomatik olarak sağlar.</p><pre>@AndroidEntryPoint<br>class ExampleActivity : AppCompatActivity() { ... }</pre><p>Güncel olarak Hilt’in desteklediği Android classları:</p><ul><li>Application (by using @HiltAndroidApp)</li><li>ViewModel (by using @HiltViewModel)</li><li>Activity</li><li>Fragment</li><li>View</li><li>Service</li><li>BroadcastReceiver</li></ul><p>!! <strong>Hilt’i Activity içinde kullanacaksanız ilgili Activity sadece ComponentActivity classını extends alan classları kullanabilir. Activityi miras alıyorsa hata alırsın.</strong></p><p><strong>!! Hilt sadece androidx.fragment tarafından import edilen fragmentları destekler.</strong></p><p><strong>!! Hilt retain fragmentları desteklemez. Retain Fragment Android uygulamalarında, bir fragmentin cihaz döndürülmesi (Configuration Changes) gibi durumlarda yeniden oluşturulmadan korunmasını sağlayan bir tekniktir. Bu özellik, fragmentin </strong><strong>setRetainInstance(true) yöntemi ile etkinleştirilir.</strong></p><blockquote><strong>Inject</strong></blockquote><p>Constructor ve Field inject olmak üzere 2 tane inject çeşidi vardır.</p><p><strong>Constructor Inject -&gt;</strong> Hilt ilgili classın nesnesinin nasıl oluşturulacağı bilmez, bunu sağlamak için ilgil classın constructorına Inject vermeniz gerekiyor.</p><pre>//Hilt knows how DataFormatter can be constructor injected<br>class DateFormatter @Inject constructor() {<br>    ...<br>}</pre><p><strong>Field Inject -&gt;</strong> Field Injection ile Hilt bağımlılıkları otomatik olarak sınıfa Inject eder ve arka tarafta nesnesini oluşturarak kullanıma hazır hale getirir. Field Injection private olamaz.</p><pre>@AndroidEntryPoint<br>class MainActivity : AppCompatActivity() {<br>    @Inject lateinit var engine: Engine<br><br>}</pre><blockquote><strong>Module ,InstallIn ve Binds</strong></blockquote><p>Module anotasyonunu sınıfın constructorını inject edemediğimiz classlar için kullanıyoruz. Bunlar;</p><ul><li>Kontrolü bizim elimizde olmayan üçüncü parti kütüphaneler (retrofit, room vs).</li><li>Android tarafından yönetilen SharedPreferences, resources gibi sınıflar.</li><li>Interface ve Abstract sınıflar.</li></ul><p>InstallIn anotasyonu Module anotasyonu ile birlikte kullanılır ve Hilt’e, hangi bileşen yaşam döngüsü sırasında bağımlılıkların sağlanacağını söyler. Hilt, farklı Android bileşenleri için farklı yaşam döngüsü kapsamları sunar ve InstallIn bu kapsamı belirtir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TGcXJoH9coeWQ6dD4-2aiQ.png" /><figcaption><a href="https://developer.android.com/training/dependency-injection/hilt-android">https://developer.android.com/training/dependency-injection/hilt-android</a></figcaption></figure><pre>interface AnalyticsService {<br>    fun analtyticsMethod()<br>}</pre><p>AnalyticsService adında bir interface tanımladık. Interfacelerin constructorına inject yapamıyoruz. Bu inject işlemini bu interface’i implement eden bir sınıf üzerinden gerçekleştireceğiz.</p><pre><br>class AnalyticsServiceImpl @Inject constructor(): AnalyticsService {<br>    override fun analtyticsMethod() {<br>        println(&quot;AnalyticsServiceImpl&quot;)<br>    }<br>}</pre><p>Interface’i implement eden bir class yazdık ve bunu Module içerisinde kullanarak inject işlemini yapacağız.</p><pre>@Module<br>@InstallIn(ActivityComponent::class)<br>abstract class AnalyticsModule {<br><br>    @Binds<br>    abstract fun bindAnalyticsService(analyticsServiceImpl: AnalyticsServiceImpl): AnalyticsService<br>}</pre><p>Buradaki Module ve IntstallIn anotasyonlarından bahsettik ama Binds anotasyonundan bahsetmedik. Binds anotasyonu Hilt’te bir interface’in veya abstract class’ın somut (concrete) bir implementasyonunu sağlamanın yoludur. Kullanıldığı fonksiyona implementasyon detayını vermiyoruz. Binds anotasyonu kullanmanın bazı koşulları vardır. Bunlar;</p><ul><li>Fonksiyon Module içerisinde bulunmalıdır.</li><li>Fonksiyon abstract olmalıdır.</li><li>Fonksiyon geri dönüş tipi interface olmalıdır.</li><li>Fonksiyon parametresi interface’i implement eden sınıf olmalıdır.</li></ul><blockquote><strong>Provides</strong></blockquote><p>Bu anotasyou genellikle 3. parti kütüphaneler için yazıyoruz. Binds gibi Module içerisinde yazıyoruz.</p><pre>@Module<br>@InstallIn(ActivityComponent::class)<br>object NetworkModule{<br><br>  @Provides<br>  fun provideRetrofit(<br>    // Potential dependencies of this type<br>  ): Retrofit {<br>      return Retrofit.Builder()<br>               .baseUrl(&quot;https://example.com&quot;)<br>               .build()<br>               .create()<br>  }<br>}</pre><p>Provides anotasyonu içerisinde ilgili sınıfın nesnesinin nasıl oluşturulacağını veriyoruz.</p><p>Hilt implementasyonunu yapmak için 3 tane kullanım senaryosu var.</p><ol><li>En basit ve kolay olan yöntem bir sınıfın constructorına müdahalede bulunabiliyorsak, kendi yazdığımız bir sınıf ise, sınıfa inject constructor vererek Hilt’i sağlayabiliriz.</li><li>Kullanacağımız yapı bir interface ise constructorına erişemiyorsak veya yoksa, bu yapıyı implement eden normal bir sınıf yazarak impl sınıfına inject constructor veriyoruz. Sonra Module sınıfı içinde Binds anotasyonuyla ilgili implementasyon sınıfını fonksiyona parametre olarak, interface’i ise dönüş tipi olarak veriyoruz. Module<strong> ve fonksiyon abstract olmalı.</strong></li><li>Retrofit room gibi const. dokunamadığımız sınıfları Module sınıfı içinde Provides anotasyonunu kullanarak nesnesinin nasıl dönüleceğini söyleyen fonksiyon yazıyoruz.</li></ol><h4>Binds vs Provides</h4><p>İş görüşmelerinde gelebilecek bir soru olan Binds vs Provides farkından bahsedelim.</p><ul><li>Binds constructor’ı inject yapamadığımız yapılar için kullanılır. Bir interface veya abstract class’ın somut bir implementasyonu ile bağlanması için kullanılır.</li><li>Provides constructor alabilen ama değişim yapamadığımız 3.parti kütüphaneler için kullanılır. Nesne yaratma işlemi daha karmaşık olduğunda veya çeşitli yapılandırmalar gerektiğinde kullanılır.</li><li>Binds soyut bir yöntemle kullanılmalıdır. Provides somut bir yöntemle kullanılmalıdır.</li><li>@Binds, @Provides&#39;a göre daha performanslıdır çünkü doğrudan bir referans bağlama işlemi yapar ve yeni bir nesne oluşturmaz.</li></ul><p>Dependency Injection kütüphanesi olan Hilt’in ne olduğuna, nasıl kullanıldığına ve bazı detaylarına değindik. Okuduğunuz için teşekkür ederim. Geri dönüşler için <a href="https://www.linkedin.com/in/cenker-aydin/">Linkedin</a> üzerinden bana ulaşabilirsiniz. İyi Günler!</p><p>Kaynaklar</p><ul><li><a href="https://www.youtube.com/@KeKod">https://www.youtube.com/@KeKod</a></li><li><a href="https://developer.android.com/images/training/dependency-injection/hilt-annotations.pdf">Hilt CheatSheet</a></li><li><a href="https://medium.com/@seungbae2/understanding-the-difference-between-provides-and-binds-in-android-hilt-88d210e358d9">https://medium.com/@seungbae2/understanding-the-difference-between-provides-and-binds-in-android-hilt-88d210e358d9</a></li><li><a href="https://developer.android.com/training/dependency-injection/hilt-android">https://developer.android.com/training/dependency-injection/hilt-android</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3478a0cfcf25" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dependency Injection (DI)]]></title>
            <link>https://blog.stackademic.com/dependency-injection-di-2d1e67c92bc8?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d1e67c92bc8</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[dependencies]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Tue, 27 Aug 2024 09:38:12 GMT</pubDate>
            <atom:updated>2024-08-28T00:53:15.655Z</atom:updated>
            <content:encoded><![CDATA[<p>Uzun bir aradan sonra herkese merhabalar. Bugün sizlere Dependency Injection konusundan bahsedeceğim. Manuel bir şekilde DI nasıl yapılır onu göreceğiz. Bir sonraki yazıda, Dependency Injection framework’ü olan Hilt’in entegrasyonunu yaparak, iş süreçlerimizi nasıl kolaylaştırdığını birlikte inceleme fırsatımız olacak. Çayınızı, kahvenizi alın ve arkanıza yaslanın. Keyifli okumalar!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/881/0*MgpV5u2FsrZl_Fqi.png" /></figure><blockquote><strong>Dependency Injection Nedir?</strong></blockquote><p>DI kısaltmasıyla bilinen Dependency Injection en basit tabiriyle üst seviyedeki modüllerin alt seviyedeki modüllere olabildiğince az bağımlı olması gerektiğini belirtir. Bağımlı olan modüller arasındaki kontrol ise soyut bir sınıf aracılığı ile olmalıdır. Yani bir sınıfın bağımlılıklarının dışarıdan sağlanmasını amaçlar.</p><p>Dependency Injection yazılım geliştirmede bağımlılıkların yönetimini daha esnek ve test edilebilir hale getirir. DI özellikle büyük ve karmaşık projelerde kodun tekrar kullanılabilirliğini artırarak boilerplate kodun önüne geçer.</p><p>!! SOLID prensiplerinin D harfi büyük bir kesimde Dependency Injection olarak bilinir ve söylenir ama aslında o D harfi Dependency Injection değil <strong>Dependency Inversion</strong> prensibidir.</p><p>Manuel DI yöntemine geçmeden önce bazı kavramları açıklamak istiyorum.</p><blockquote><strong>Inversion Of Control Prensibi</strong></blockquote><p>Bir nesnenin nasıl oluşturulacağı ve nasıl kullanılacağına karar verme yetkisini başka bir yapıya verilmesidir. Bunu yaparak sınıflar veya modüller arası bağımlılığında en aza indirgenmesini sağlar. Bir methodun implementasyonundan izole hareket etmesine olanak tanır.</p><blockquote><strong>Tightly Coupled (Sıkı Bağlılık)</strong></blockquote><p>Bir sınıfın nesnesi başka bir sınıf içinde direkt oluşturuluyorsa bu iki sınıf birbirine sıkı sıkıya bağlı olur. Tightly Coupled denir. Bu kullanımdan olabildiğince uzak durmak gerekiyor çünkü test etmesi, yönetmesi zor bir yapı olur.</p><pre>class Engine {<br>    fun start() {<br>        println(&quot;Engine started&quot;)<br>    }<br>}<br><br>class Car {<br>    private val engine = Engine() // Tightly Coupled<br><br>    fun startCar() {<br>        engine.start()<br>        println(&quot;Car is running&quot;)<br>    }<br>}</pre><p>Kod bloğunda gördüğünüz gibi Car classı içerisinde Engine classının nesnesini oluşturduk ve bu iki sınıf birbirine Tightly Coupled oldu.</p><p>Burada Car sınıfı Engine sınıfı olmadan iş yapamaz. Tek başına anlamsız bir hale geliyor. Car sınıfı başka bir yerde kullanılmak istediği zaman Engine sınıfı ile birlikte kullanılmak zorunda ve bağımlılığı yüzünden kod tekrarına sebebiyet verecektir.</p><p>Engine sınıfında yapılan bir değişiklik Car sınıfı da etkiler. Bu durum kodun yönetilebilirliğine zarar verir.</p><blockquote><strong>Loosely Coupled (Gevşek Bağlılık)</strong></blockquote><p>Tightly Coupled kavramının tam tersidir. Yukarıda gördüğünüz kod bloğunda bizim birden fazla DieselEngine, GasEngine vs sınıflarımız olması istense kullanılması gereken sınıfta sürekli olarak ilgili classın nesnesini oluşturmak zorunda kalacağız. Bu durumu Engine adında soyut bir sınıfa vererek daha kolay yönetilebilir ve Loosely Coupled olan sınıflar yazacağız. Manuel DI anlatırken bu örnek üzerinden ilerleyeceğimiz için burayı geçiyorum.</p><blockquote><strong>Cohesion</strong></blockquote><p>Bir sınıfın ne kadar iyi tanımlanmış olduğunun derecesidir. Bir sınıf kendi temel işi dışında başka işlerde yapıyorsa cohesion düşer. Coupled ve Cohesion birbiriyle ters orantılı olarak çalışır. Tightly Coupled bir yapı Low cohesion, Loosely Coupled bir yapı High Cohesion olur.</p><p>Kavramları açıkladıktan sonra Manuel DI nasıl yapılır onun örneğine geçelim. Kemerlerinizi bağlayın uçuşa geçiyoruzz!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*Bxk1shuknPmgrEGZ.gif" /><figcaption><a href="https://giphy.com/">https://giphy.com/</a></figcaption></figure><blockquote><strong>Manuel DI</strong></blockquote><p>Manuel DI işlemine geçmeden önce basit bir şekilde bir Car ve bir Engine sınıfımız olsun ve Car sınıfı Engine sınıfına bağımlı olsun.</p><pre>class Engine {<br>    fun start() {<br>        println(&quot;Engine started&quot;)<br>    }<br>}<br><br>class Car {<br>    private val engine = Engine() <br><br>    fun startCar() {<br>        engine.start()<br>        println(&quot;Car is running&quot;)<br>    }<br>}</pre><p>Basit bir şekilde hiçbir prensip ve yöntem düşünmeden kodumuzu yazdık. Bu iki class birbirine sıkı bağımlıdır. Bu durum bizim kodumuzun yönetilmesini zorlaştıracak , yeni geliştirmeler için birden fazla yerde kod bloğu yazmamızı gerektirecek. Mesela biz artık Engine sınıfı yerine DieselEngine, GasEngine ve PetrolEnginegibi yeni yapılar eklemek durumunda kalsak bunu nasıl yönetmemiz gerekirdi ?</p><pre>interface Engine {<br>    fun start() <br>}<br><br>class GasEngine: Engine{<br>    override fun start() {<br>        println(&quot;Gas engine started&quot;)<br>    }<br>}<br>class DieselEngine: Engine {<br>    override fun start() {<br>        println(&quot;Diesel engine started&quot;)<br>    }<br>}<br>class PetrolEngine: Engine {<br>    override fun start() {<br>        println(&quot;Petrol engine started&quot;)<br>    }<br>}<br><br>class Car(private val engineType: EngineType){<br>    private var gasEngine =  GasEngine()<br>    private var dieselEngine = DieselEngine()<br>    private var petrolEngine = PetrolEngine()<br><br>    fun start(){<br>        when(engineType){<br>            EngineType.GAS -&gt; gasEngine.start()<br>            EngineType.DIESEL -&gt; dieselEngine.start()<br>            EngineType.PETROL -&gt; petrolEngine.start()<br>        }<br>    }<br>}<br><br>enum class EngineType{<br>    GAS,<br>    DIESEL,<br>    PETROL<br>}<br></pre><p>Bu şekilde bir kod bloğu yazabiliriz, ancak burada hala bir kod kokusu (code smell) mevcut çünkü Car sınıfı, Engine sınıflarına hala sıkı sıkıya bağlı (tightly coupled). Car sınıfı içinde diğer sınıfların nesnelerini oluşturmak, bu sınıfın bağımlılıklarını yönetmeyi zorlaştırır ve esnekliğini azaltır. Bu nedenle, Car sınıfı içinde diğer sınıfların nesnelerini oluşturmaktan kaçınmalıyız.</p><pre>class Car(private val engine: Engine){<br>    fun start(){<br>        engine.start()<br>    }<br>}</pre><p>Car sınıfının Manuel DI uygulanmış hali yukarıda gördüğünüz gibidir. Sınıfımızı Loosely Coupled yaptık bu sayede High Cohesion oldu. Car sınıfımıza Engine classının nesnesini doğrudan yazmak yerine dışarıdan alıyoruz bu sayede Car sınıfını esnek bir yapıya kavuşturuyoruz, farklı Engine türleriyle rahatça çalışmasını sağlıyoruz.</p><pre>fun main()  {<br>    val electricEngine= GasEngine()<br>    val car1 = Car(electricEngine)<br>    car1.start() //Gas engine started<br><br>    val dieselEngine = DieselEngine()<br>    val car2 = Car(dieselEngine)<br>    car2.start() //Diesel engine started<br><br>   <br>}</pre><p><strong>Manuel DI sayesinde</strong></p><ul><li>Bağımlılıkları, sınıfların içinde doğrudan oluşturmaktan kaçınarak dışarıdan sağladık. Bu, sınıfın bağımlılıklarını dışarıdan almasını ve bunları yönetmeyi kolaylaştırır.</li><li>Bir sınıfın diğer sınıflara sıkı sıkıya bağlı olmasını engelledik. Bu, kodun daha esnek ve test edilebilir olmasını sağlar çünkü bağımlılıklar dışarıdan enjekte edilir ve kolayca değiştirilebilir.</li><li>Bağımlılıkların ne zaman ve nasıl oluşturulacağını belirleme kontrolünü sınıfın dışındaki kodun (tüketicinin) eline verdik. Bu, özellikle karmaşık nesne oluşturma süreçlerinde önemlidir.</li><li>Bağımlılıkları dışarıdan enjekte etmek, aynı sınıfı farklı senaryolarda yeniden kullanmayı kolaylaştırır. Farklı bağımlılıklarla çalışmak için sınıfın içeriğini değiştirmek gerekmez.</li></ul><p>Buraya kadar okuduğunuz için teşekkür ederim bir sonraki yazıda görüşmek üzere!</p><p><strong>Kaynakça</strong></p><ul><li><a href="https://gokhana.medium.com/inversion-of-control-ioc-nedir-ve-avantajlar%C4%B1-nelerdir-cf05e42c16e4">Inversion Of Control ( IoC ) Nedir ve Avantajları Nelerdir ?</a></li><li><a href="https://www.youtube.com/@KeKod">KeKod</a></li><li><a href="https://medium.com/@KaushalVasava/manual-dependency-injection-in-android-a-beginner-guide-172f0ff9e715">Manual Dependency Injection in Android. A Beginner guide</a></li><li><a href="https://developer.android.com/">Android Mobile App Developer Tools - Android Developers</a></li></ul><h3>Stackademic 🎓</h3><p>Thank you for reading until the end. Before you go:</p><ul><li>Please consider <strong>clapping</strong> and <strong>following</strong> the writer! 👏</li><li>Follow us <a href="https://twitter.com/stackademichq"><strong>X</strong></a> | <a href="https://www.linkedin.com/company/stackademic"><strong>LinkedIn</strong></a> | <a href="https://www.youtube.com/c/stackademic"><strong>YouTube</strong></a> | <a href="https://discord.gg/in-plain-english-709094664682340443"><strong>Discord</strong></a></li><li>Visit our other platforms: <a href="https://plainenglish.io/"><strong>In Plain English</strong></a> | <a href="https://cofeed.app/"><strong>CoFeed</strong></a> | <a href="https://differ.blog/"><strong>Differ</strong></a></li><li>More content at <a href="https://stackademic.com/"><strong>Stackademic.com</strong></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d1e67c92bc8" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/dependency-injection-di-2d1e67c92bc8">Dependency Injection (DI)</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Veri Yapıları - LinkedList]]></title>
            <link>https://medium.com/yetkingencler/veri-yap%C4%B1lar%C4%B1-linkedlist-4dd1163b6ae6?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dd1163b6ae6</guid>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[yetkin-gençler]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[yetgenli]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Fri, 08 Dec 2023 10:02:09 GMT</pubDate>
            <atom:updated>2023-12-13T06:47:40.627Z</atom:updated>
            <content:encoded><![CDATA[<p>Herkese Merhabalarr! Bu yazıda Veri yapılarına (Data Structures) giriş yapacağız. Veri yapıları bilgisayar bilimlerinde ve programlamada temel bir kavramdır ve bellek yönetimi, algoritma tasarımı vb. konularda önemli avantajlar sunar. Zaman kaybetmeden önemli bir veri yapısı olan LinkedList ile başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mEs5PNZnOJZUq3HCBxNxSw.jpeg" /><figcaption><a href="https://unsplash.com/photos/turn-on-flat-screen-computer-monitor-IKUYGCFmfw4">https://unsplash.com</a></figcaption></figure><blockquote><strong><em>LinkedList</em></strong></blockquote><p>LinkedList, linear bir veri yapısıdır.</p><p><strong>Linear Veri Yapısı:</strong> Elemanların birbirine sıralı bir şekilde bağlandığı ve her eleman bir önceki ve bir sonraki eleman ile ilişkilidir. Linear Veri yapılarına Arrays, Stacks, Queues ve LinkedListler örnek gösterilebilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*6ReSYwX-z-n4jWPCRSxqBw.png" /><figcaption><a href="https://www.geeksforgeeks.org/">https://www.geeksforgeeks.org/</a></figcaption></figure><p>Fotoğrafta görüldüğü üzere LinkedList elemanları birbiriyle bağlantılıdır. Her bir elemana Node(düğüm) ismi verilir ve her bir node, data( kendisine ait değer) ve bir sonraki düğümün referansını içerir (next).</p><p><strong>Head Node</strong>: LinkedList içerisindeki en baştaki düğümdür.</p><p><strong>Tail Node</strong>: LinkedList içerisindeki en son düğümdür. En son düğümün referans değeri başka düğümü gösteremeyeceğinden null olacaktır.</p><p>LinkedList türlerine geçmeden önce LinkedList avantajlarına ve dezavantajlarına bakalım.</p><h4><strong><em>Avantajları</em></strong></h4><ul><li>LinkedList dinamiktir. Eleman ekleme veya çıkarma işlemleri arraylere kıyasla daha efektif olabilir.</li><li>LinkedList içinde eleman ekleme veya çıkarma işlemleri daha hızlıdır çünkü bunu yapmak için sadece ilgili düğümün referansları üzerinde işlem yapmak yeterli olacaktır.</li><li>LinkedList ile birçok veri yapısını farklı dillerde implement edebiliriz (Stack, Queue, Graph, Hash Maps).</li></ul><h4><strong>Dezavantajları</strong></h4><ul><li>LinkedList, bir diziden farklı olarak rastgele erişime izin vermez. Belirli konumdaki ögeye ilerlemek için tek tek düğümleri dolaşmak gerekebilir. Küçük boyutlu listelerde bu durum çok göze batmasa bile boyut büyüdükçe performans sorununa yol açabilir.</li></ul><p>Genellikle Array veri yapısı yerine LinkedList veri yapısı kullanılır ama bu durum array veri yapısının verimsiz olduğu anlamına gelmez. Projeye veya o anki şartlara göre programcı array mi linkedList mi kullanacağına kendi karar vermelidir.</p><figure><a href="https://www.linkedin.com/company/yetkingencler/about/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5MxZg1i9SZOsr9yyWV8DAA.png" /></a></figure><blockquote><strong><em>LinkedList Türleri</em></strong></blockquote><p><strong>Single-Linked List</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*xFmRv1hjwBEgaYSKAl4piw.png" /><figcaption><a href="https://www.geeksforgeeks.org/">https://www.geeksforgeeks.org/</a></figcaption></figure><p>En başta bahsettiğimiz LinkedList tanımı Single-LinkedList içinde geçerlidir. LinkedList implementasyonunda genellikle Single-LinkedList kullanılır.</p><p><strong>Double-LinkedList</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cFqdQdCHmyj1Bx-8edwdAA.png" /><figcaption><a href="https://www.geeksforgeeks.org/">https://www.geeksforgeeks.org/</a></figcaption></figure><p>Double-LinkedListte her bir düğüm bir sonraki ve bir önceki düğümün referansını içerir. Bu sayede Double-LinkedList üzerinde hem ileri hem de geri yönlü hareket edebilirsiniz.</p><p><strong>Prev</strong>: Önceki düğümün referansını işaret eder. En baştaki düğümde null olacaktır.</p><p><strong>Next</strong>: Bir sonraki düğümün referansını işaret eder. En sondaki düğümde null olacaktır.</p><p><strong>Circular LinkedList</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*yLWedbxfdPkJephjhX5RoA.png" /><figcaption><a href="https://www.geeksforgeeks.org/">https://www.geeksforgeeks.org/</a></figcaption></figure><p>Burada son düğümün referansı en baştaki düğümün datasını (veri) işaret eder.</p><p>Kod üzerinde LinkedList veri yapısına göz atalım.</p><pre>class LinkedList { <br>    Node head; <br>  <br>    class Node { <br>        int data; <br>        Node next; <br>  <br>       <br>        Node(int d) <br>        { <br>            data = d; <br>            next = null; <br>        } <br>    } <br>}</pre><p>LinkedList classının içine nested bir Node classı oluşturduk ve içinde gerekli işlemleri yaptık.</p><p>LinkedList’de en başa yeni bir node (düğüm) eklemek için aşağıdaki kodu yazmanız gerekiyor.</p><pre>class LinkedList{<br>   class Node{<br>    int data;<br>    Node next;<br>    Node(int d){<br>    data=d;<br>    next=null;  <br>    }<br>  }<br><br> Node head;<br>  public void push(int newData){<br>  Node newNode= new Node(newData);<br>  newNode.next=head;<br>  head=newNode;<br>  }<br>}</pre><p>Peki en sona eklemek için neler yapmalıyız?</p><pre>class LinkedList{<br>   class Node{<br>    int data;<br>    Node next;<br>    Node(int d){<br>    data=d;<br>    next=null;  <br>    }<br>  }<br>  Node head;<br>  public void pushLast(int newData){<br>  //Eklemek için yeni bir node oluşturuyoruz.<br>  Node newNode=new Node(newData);<br>  <br>  //Eğer linkedList boşsa yeni oluşturduğumuz node head olarak atıyoruz <br>  //return ile işlemimiz bitiyor.<br>  if(head==null){<br>  head=new Node(newData);<br>  return;<br>  }<br>  //En sona ekleyeceğimiz için newNodeun referansını null olarak atıyoruz.<br>  newNode.next=null;<br>  <br> <br>  //Son düğümün referansı null olacağı için onu bulana kadar düğümleri geziyoruz.<br>  Node last=head;<br>  while(last.next !=null){<br>  last=last.next;<br>  }<br>  //En son düğümü newNode olarak değiştiriyoruz.<br>  last.next=newNode;<br>  return;<br>  }<br>}</pre><p>En başa ve en sona eklemeyi gördük peki başa ve sona değil, istediğimiz bir düğümden sonra eklemek istersek neler yapmamız gerekiyor?</p><pre>public void insertAfter(Node prev_node, int new_data)<br>{<br>    //Parametre olarak verilen düğümün null olup olmadığını kontrol ediyoruz.<br>    if (prev_node == null) {<br>        System.out.println(<br>            &quot;The given previous node cannot be null&quot;);<br>        return;<br>    }<br> <br>    //Yeni bir node oluşturuyoruz.<br>    Node new_node = new Node(new_data);<br> <br>    //Verilen düğümün referansını yeni oluşturduğumuz düğümün referansına atıyoruz<br>    //çünkü parametre olarak verilen düğümün sonrasına ekleme yapacağız.<br>    new_node.next = prev_node.next;<br> <br>    //yeni oluşturduğumuz düğümü verilen düğümün referansına atayarak düğümü eklemiş oluyoruz.<br>    prev_node.next = new_node;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*LoDTxbV_Vd766q6aQu3WgQ.png" /></figure><p>Kod içinde yorum satırında neler yaptığımızı tek tek anlattım ama fotoğrafa bakarak ilerlerseniz daha kalıcı olacağını düşünüyorum.</p><p>Bir sonraki yazılarda görüşmek üzere!</p><p><a href="https://www.linkedin.com/in/cenker-aydin/">Linkedin</a> , <a href="https://twitter.com/Cenktodiie">Twitter</a></p><blockquote><strong>Kaynakça</strong></blockquote><p><a href="https://www.geeksforgeeks.org/data-structures/linked-list/">Linked List Data Structure - GeeksforGeeks</a></p><figure><a href="https://medium.com/yetkingencler/yetkin-yay%C4%B1n-yay%C4%B1n-politikas%C4%B1-91a74e63df5"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wi0biE1fQ3LuAkEBmLcn6g.png" /></a></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dd1163b6ae6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yetkingencler/veri-yap%C4%B1lar%C4%B1-linkedlist-4dd1163b6ae6">Veri Yapıları - LinkedList</a> was originally published in <a href="https://medium.com/yetkingencler">Yetkin Yayın</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android UI Bileşenleri]]></title>
            <link>https://medium.com/yetkingencler/android-ui-bile%C5%9Fenleri-2ca714a7e5f3?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ca714a7e5f3</guid>
            <category><![CDATA[yetkin-gençler]]></category>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[yetgenli]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Tue, 31 Oct 2023 08:29:13 GMT</pubDate>
            <atom:updated>2023-10-31T10:44:19.745Z</atom:updated>
            <content:encoded><![CDATA[<p>Hepinize merhaba arkadaşlar, bugün sizlerle birlikte android uygulama geliştirirken tasarım konusunda işlerimizi kolaylaştıracak birkaç UI bileşeninden bahsedeceğim. Beğenmeyi unutmayın. Hazırsanız başlayalım! 🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KmYOMXdRjBLOvN3y1SW-wA.jpeg" /></figure><p>Öncelikle, UI nedir ve hangi amaçla kullanılır bunu kısaca açıklamak istiyorum.</p><blockquote><strong>User Interface </strong>kısaca UI olarak bilinir ve Türkçeye Kullanıcı Arayüzü olarak geçmiştir. Kullanıcı Arayüzü, insanların yazılım sayesinde bilgisayarlar ve cihazlar ile etkileşime geçtiği noktadır diyebiliriz. UI tasarımı, kullanıcının uygulamayı kullanırken karşılaştığı görsel ögeleri, butonları, metinleri, renkleri ve diğer etkileşim ögelerini tasarlama ve düzenleme sürecidir. Efektif bir UI tasarımı, kullanıcının uygulamayı kullanırken zorlukla karşılaşmamasını, kullanıcı deneyimini iyileştirmeyi ve uygulamanın estetik olarak görünmesini amaçlar ve bu şekilde kullanıcı dostu, estetik ve çekici arayüzler oluşturarak kullanıcının ürünle daha olumlu bir etkileşim deneyimlemesine yardımcı olur.</blockquote><p>Şimdi Android geliştirirken hangi UI bileşenlerini kullanıyoruz bunlara birlikte bakalım.</p><p>Öncelikle UI kısmına nasıl geçeceğini bilmiyorsanız şu adımları izleyebilirsiniz</p><p>Öncelikle Android Studio üzerinden yeni bir proje açmanız gerekiyor, projeyi açtıktan ve gerekli düzenlemelerin yapılmasını bekledikten sonra sol tarafta Project dosyasını açın. Project dosyasında res klasörüne girip layout dosyasını seçtiğiniz zaman activity_main.xml dosyasını göreceksiniz onu açtığınız zaman UI tasarımı kısmına geçmiş olacaksınız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*01UfzPVPKigruW6hILivuQ.png" /></figure><p>activity_main.xml açtığınız zaman sizi aşağıdaki görseldeki gibi bir ekran karşılayacak</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RvLlFo2e0FI4kNwIOkBW4Q.png" /></figure><p>Şimdi bu ekranı detaylı bir şekilde inceleyelim 🚀</p><p>Öncelikle solda Palette kısmını görüyorsunuz bu genel olarak UI bileşenlerinin bulunduğu ve tasarım kısmına atabileceğimiz UI bileşenlerini gösteriyor, ana odağımız burası olacak ama öncesinde ekranın diğer kısımlarında ne var ona bakalım;</p><figure><a href="https://www.instagram.com/yetkingencler/"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AUvTw4kceuuMVWrEjPZEQQ.png" /></a></figure><p>Ortada gördüğünüz iki ekran üzerinde tasarımı yapıyoruz diyebilirim, beyaz ekran design diye geçer. Bu ekran üzerinde UI bileşenlerini ekleyip onların ekran üzerinde nasıl görüneceğini ayarlayabiliyoruz. Mavi ekran ise blueprint olarak geçer burada pek bir işlem yapmayacağız, bu ekranın amacı design kısmında koyduğumuz bileşenlerin nasıl konumlandığınız izleyebiliyoruz.</p><p>Palette kısmının solunda activity_main.xml yazısına tıkladığınız zaman sizi böyle bir ekran karşılayacak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*CoWNaAKaILUeURNmhUZQqw.png" /></figure><p>Fark ettiyseniz activity otomatik vertical (dikey) olarak oluşturuldu, bu ekranda eğer isterseniz landscape (yatay) olarak activity oluşturabilir yatay olarak yapacağınız uygulamalara yönelik işlemler yapabilirsiniz.</p><p>activity_main.xml yanında yer alan mavi logoda ise yukarıda bahsettiğimiz beyaz ve mavi ekranlardan hangisini görmek isterseniz ona göre işlem yapabilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*4iAGVb2qJ8yvtV4Grrt56Q.png" /></figure><p>Yanda yer alan yatay telefon logosunda portrait (dikey) ve landscape (yatay) seçenekleri mevcuttur istediğinizi seçerek ona göre işlem yapabilirsiniz.</p><p>Android logosunda ise uygulamanızın hangi API değerinde çalışacağına karar veriyorsunuz bu konu yaptığınız uygulamayı Google Play’de yayınlamak istediğiniz zaman önemli bir konuma geliyor çünkü seçeceğiniz API değeri birçok telefonu kapsaması lazım yoksa sürümü eski olan telefonlar uygulamanızı indirip, kullanamaz.</p><p>Bu kısmın hemen altında göz logosunu göreceksiniz ona tıkladığınız zaman çeşitli seçenekler var.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/406/1*drL3qUPoO2zxXfIR3iB2Qg.png" /></figure><p>Burada tasarım yaparken neleri görmek istiyorsunuz ona göre seçim yapabilirsiniz.</p><p>Yanında mıknatıs işareti göreceksiniz bunu açık tutarsanız koyduğunuz bir bileşen otomatik olarak constraint olacaktır.</p><p>0 dp yazan yerde koyacağınız bileşenler default olarak kaç dp aralıklı başlayacağını yazabilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*U36EfuU02BGNIa8nLxKdXg.png" /></figure><p>Şu an için 0 olması sizin için daha uygun olacaktır.</p><p>Yanındaki logo ise bastığınız zaman bütün constraintleri (kısıtlama) kaldırır.</p><p>Ekranın sağ tarafında code ,split ve design kısımlarını görebilirsiniz eğer sadece code kısmını seçerseniz karşınıza xml ekranı gelecektir burada xml kodlama sayesinde tasarımlarınızı yapabilirsiniz. Split kısmı ise ekranı ikiye bölerek hem xml kodlarınızı yazabileceğiniz hem de design kısmında ne olup bittiğiniz görebileceğiniz bir ortam sunar. Design kısmı ise en başta gösterdiğim sayfayı yani sadece design yapabileceğiniz sayfayı gösterir.</p><figure><a href="https://twitter.com/yetkingencler"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KdIs9EZ3cT7xXcaOeSnA3g.png" /></a></figure><p>En son olarak ekranın en sağında görünen Attributes kısmında koyduğunuz bileşenlerin id, size, text, color yani neredeyse her şeyini ayarlayabilirsiniz, bu kısmı iyi anlarsanız işleriniz kolaylaşır.</p><p>Evet şimdi en güzel kısıma geldik! Sizlere Android UI bileşenlerini elimden geldiğince anlatmaya çalışacağım. Haydi başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*vGm_q6hKwNGyMc7NZRMeZQ.gif" /></figure><blockquote><strong><em>Layout</em></strong></blockquote><p>Android uygulamalarında kullanıcı arayüzünü oluşturmak için xml dosyasında yer alan düzenleyicilere genel olarak “Layout” denir. Layoutlar genel olarak uygulama ekranının nasıl görüneceğini ve UI bileşenlerinin ekranda nasıl konumlanacağını ayarlamamıza yardımcı olur.</p><p>Sıklıkla kullandığımız Layoutlara göz atalım.</p><h4><strong>Linear Layout</strong></h4><p>Eğer Android uygulama geliştirme yapmaya yeni başladıysanız ilk kısımlarda Linear Layout ile içli dışlı olacağınızı belirtmek istiyorum. Linear Layout genel olarak bileşenleri dikey veya yatay olarak tek bir yönde hizalayan bir görüntüleme grubudur. Dikey veya yatay olmasını “<strong>android:orientation</strong>” kullanarak belirleyebilirsiniz.</p><p>Şimdi xml kullanarak Linear Layout oluşturalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*zhYTZO0QBhOZbA86wg_NQw.png" /></figure><p><strong>xmlns:android , xmlns:tools, tools:context </strong>otomatik olarak geliyor, bizim burada düzenleyebileceğimiz şeyler width , heigth ve orientation.</p><p>width ve height özelliklerinin genelde 2 seçeneği vardır, match_parent ve wrap_content.</p><blockquote><strong><em>match_parent</em></strong></blockquote><p>Bu değer, bir bileşenin genişlik veya yükseklik yönünde içinde bulunduğu layout kadar geniş yapılmasını veya yüksek olmasını sağlar. Linear Layout için ise match_parent olması ekran genişlik veya yükseklik yönünde tamamlamasını sağlar yanı kısaca ekrana tam sığar.</p><blockquote><strong><em>wrap_content</em></strong></blockquote><p>Bu değer, bir bileşenin içeriğine uygun olarak genişliğini veya yüksekliğini ayarlar. Yani, bir bileşenin içeriği kadar alan kaplamasını sağlar.</p><blockquote><strong><em>orientation</em></strong></blockquote><p>Orientation ise linear layoutun vertical (dikey) ve horizantal (yatay) olarak hangi şekilde olmasını isterseniz düzenleyebilirsiniz.</p><p>Linear Layout, basit ve anlaşılır olması, esneklik sağlaması ile geliştiriciler tarafından oldukça kullanılır.</p><h4><strong><em>Constraint Layout</em></strong></h4><p>ConstraingLayout, Android geliştirirken kullanıcı arayüzü oluşturmak için kullanacağınız layout çeşitlerinden birisidir. ConstraintLayout, bileşenlerin birbirleriyle ve ekran kenarlarıyla olan constraintlerini belirlemek için kullanılır. Genel olarak daha karmaşık düzenler için kullanılır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1016/1*1hsr16Twa7iShhsUYhqGXg.png" /></figure><p>Basitçe bir ConstraintLayout oluşturmak için gerekli xml kodları yukarıda gösterildiği gibidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4h6kjUd6GbawiruzPJ6eFg.png" /><figcaption><a href="https://developer.android.com/develop/ui/views/layout/constraint-layout?authuser=1&amp;hl=tr">https://developer.android.com/develop/ui/views/layout/constraint-layout?authuser=1&amp;hl=tr</a></figcaption></figure><p>Görselde gördüğünüz gibi constraintLayout’ın en büyük avantajı bileşenler arasındaki constraintleri kendimiz belirleyerek hangi bileşenin nerede olacağına kendimiz karar verebiliyoruz.</p><p>ConstraintLayout içine atılan herhangi bir bileşenin en az bir horizantal ve bir vertical bir constraint’i olması gerekiyor.</p><p>LinearLayout ve ConstraintLayout dışında kullanılan layout çeşitleri var ancak en sık kullanılan bu ikisi olduğu için şu an bunları bilmeniz yeterli olacaktır.</p><p>Yazıyı daha fazla uzatmamak için diğer UI bileşenlerine bir sonraki yazıda yer vereceğim. Bir sonraki yazıya kadar kendinize çok iyi bakın, Android ile kalın! :D</p><blockquote><strong><em>Kaynakça</em></strong></blockquote><p><a href="https://developer.android.com/?hl=tr&amp;authuser=1">https://developer.android.com/?hl=tr&amp;authuser=1</a></p><p>Bana <a href="https://www.linkedin.com/in/cenker-aydin/">buradan</a> ulaşabilirsiniz.</p><figure><a href="http://Yetkin%20Yayın%20-%20Yayın%20Politikası.%20Yetkin%20Yayın%20olarak,%20değer%20üreten…%20|%20by%20Yetkin%20Gençler"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ArpcHvjzrRwDiuIopfu1bQ.png" /></a></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ca714a7e5f3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yetkingencler/android-ui-bile%C5%9Fenleri-2ca714a7e5f3">Android UI Bileşenleri</a> was originally published in <a href="https://medium.com/yetkingencler">Yetkin Yayın</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Activity LifeCycle]]></title>
            <link>https://medium.com/@cenkeraydin14/activity-lifecycle-e74034f4c403?source=rss-a4d078479e25------2</link>
            <guid isPermaLink="false">https://medium.com/p/e74034f4c403</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[programlama]]></category>
            <category><![CDATA[yetkin-gençler]]></category>
            <category><![CDATA[yetgenli]]></category>
            <category><![CDATA[activity-lifecycle]]></category>
            <dc:creator><![CDATA[Cenker Aydın]]></dc:creator>
            <pubDate>Fri, 22 Sep 2023 09:01:38 GMT</pubDate>
            <atom:updated>2024-07-17T15:09:53.483Z</atom:updated>
            <content:encoded><![CDATA[<p>Herkese merhabalarrr! Umarım keyfiniz yerindedir. Bugün sizlerle birlikte bence Android öğrenirken en başta öğrenilmesi gereken konulardan olan Activity LifeCycle (Yaşam Döngüsü) konusunu ele alacağız. Kahvelerinizi veya çaylarınızı aldıysanız başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HuHkYQAiJboUZhzzBuBruw.jpeg" /><figcaption><a href="https://unsplash.com/photos/HfWA-Axq6Ek">https://unsplash.com/photos/HfWA-Axq6Ek</a></figcaption></figure><blockquote><strong><em>Activity Nedir?</em></strong></blockquote><p>Activity lifecycle geçmeden önce activitynin ne olduğunu inceleyelim. Activity (etkinlik), Android tabanlı uygulamalarda, uygulamanın kullanıcıyla etkileşime geçmesini sağlayan bir arayüz gibi düşünebiliriz. Android uygulamalarında ekran görüntüsünü temsil eder ve kullanıcıya bir UI (kullanıcı arayüzü) sunar. Bir activity, kullanıcıyla etkileşime girmek, kullanıcıdan girdi almak, diğer activitylerle etkileşimde bulunmak ve uygulamanın belirli bir işlevselliğiyle ilgili görevleri gerçekleştirmek için kullanılır. Genellikle bir veya daha fazla aktivite içerir ve her aktivite, uygulamanın farklı bir ekranını yönetir.</p><blockquote><strong>Activity LifeCycle Nedir?</strong></blockquote><p>Activity LifeCycle (Yaşam Döngüsü), bir Android uygulamasında aktivitenin oluşturulduğu andan itibaren kullanıcı tarafından kapatılıncaya kadar geçirdiği aşamalardan oluşur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5b9XGv5p8sKt-JyqPSIlOg.png" /><figcaption><a href="https://developer.android.com/guide/components/activities/activity-lifecycle?hl=en">https://developer.android.com/guide/components/activities/activity-lifecycle?hl=en</a></figcaption></figure><p>Görselde göreceğiniz üzere 6 ana hattan oluşan bir döngüdür. Gelin bunları teker teker inceleyelim.</p><blockquote><strong><em>onCreate()</em></strong></blockquote><p>Activity’nin yeni oluşturulduğu durumdur. Ancak activity görünür değildir ve kullanıcı ile etkileşim halinde değildir.</p><p>Activity ilk başladığında çağrılır ve activity lifecycle boyunca sadece 1 kez çağrılır. Her activity için gerekli bir methodtur. Burada tekrar çağrılmayacak işlemler yapılır. Örneğin görünümleri bağlamak (findViewById ya da viewBinding ile) burada yapılır. Kullanılacak nesneler burada oluşturulabilir çünkü activity arka plana alınsa ve tekrar çalışsa dahi destroy olmadığı sürece onCreate tekrar çalışmaz ve bu durum performans optimizasyonunu sağlar. Android studio üzerinden yeni bir app oluşturulduğunda otomatik olarak gelir ve şu şekilde gözükür.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*pZzjSqRZybaTbvpm8MagTw.png" /></figure><blockquote><strong><em>onStart()</em></strong></blockquote><p>onCreate’den sonra ilk olarak çağrılan methodtur. Activitynin görünür hale geldiği durumdur. Kullanıcı activityden uzaklaşırken veya geri geldiğinde birden çok kez çağrılabilir. Eğer activity arka planda çalışır olursa onResume() methodu çağrılır.</p><blockquote><strong><em>onResume()</em></strong></blockquote><p>Activity’nin running olduğu durumdur. Kullanıcı tarafından görüldüğü ve etkileşime geçildiği durumdur. Activity kullanıcı tarafından kapatılıp, arka plana düşerse onPause() methodu çağrılır.</p><blockquote><strong><em>onPause()</em></strong></blockquote><p>Uygulama arka plana düştüğünde, kullanıcının etkileşime girmediği durumlarda ortaya çıkar. onResume() methodunun aynası diyebiliriz. Genellikle geri veya home tuşuna basıldığında çağrılır. Çoklu ekran kullanımı mümkün olan android cihazlarında diğer pencereye geçildiğinde devreye girer.</p><blockquote><strong><em>onStop()</em></strong></blockquote><p>Activitynin kullanıcı tarafından uzun süre boyunca görülmediği durumda çağrılır. 2 durumda farklı methodlar çağrılabilir. Eğer kullanıcı activityi tekrar açarsa onRestart() methodu çağrılır, eğer kullanıcı activityi kapatır ve sonlandırırsa onDestroy() methodu çağrılır.</p><blockquote><strong><em>onRestart()</em></strong></blockquote><p>onStop() methodundaki bir appi kullanıcı tekrar açarsa onRestart() methodu ile lifecycle döngülerinden olan onStart() fonksiyonu çağrılır.</p><blockquote><strong><em>onDestroy()</em></strong></blockquote><p>Activity yaşam döngüsünün çıkış noktasıdır. Kullanıcı artık uygulama ile etkileşim halinde değildir ve uygulamayı görmüyordur. Activity kullanıcı ile bağlantııs kesildiği için kullanılan veriler temizlenebilir. Örnek olarak banka uygulaması destroy olduğunda ve siz tekrar girmek istediğinizde sizi login ekranına yönlendirir ve güvenlik için sizden tekrar şifre talep edebilir.</p><p><strong>Uygulama açıldığında</strong></p><p>onCreate() -&gt; onStart() -&gt; onResume()</p><p><strong>Uygulamada geri tuşuna veya home tuşuna basıldığında</strong></p><p>onPause() -&gt;uzun süre işlem yapılmazsa -&gt; onStop() -&gt; onDestroy()</p><p><strong>Home tuşuna basıldıktan sonra uygulamaya geri dönüldüğünde</strong></p><p>onRestart() -&gt; onStart() -&gt; onResume()</p><p>Activity’nin yaşam döngüsü, genellikle kullanıcı ile etkileşimde bulunmanın farklı aşamalarına uygun şekilde tepki vermesini sağlamak için kullanılır. Developerlar bu yaşam döngüsünü doğru bir şekilde yöneterek kullanıcı deneyimini iyileştirebilir ve kaynakları verimli bir şekilde kullanabilir.</p><p>Kaynakça:</p><p><a href="https://developer.android.com/guide/components/activities/activity-lifecycle?hl=en">Android Developers Activity Lifecycle</a></p><p><a href="https://www.geeksforgeeks.org/activity-lifecycle-in-android-with-demo-app/">Activity Lifecycle in android</a></p><p>Okuduğunuz için teşekkür ederim. Sonraki yazılarda görüşmek üzere!</p><p><a href="https://www.linkedin.com/in/cenker-aydin/">Linkedin</a> , <a href="https://twitter.com/Cenktodiie">Twitter</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e74034f4c403" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>