<?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 Muratdayan on Medium]]></title>
        <description><![CDATA[Stories by Muratdayan on Medium]]></description>
        <link>https://medium.com/@muratdayan359?source=rss-36dbfa40b935------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nl5X8m3xD6u7YIN6ascxFw.jpeg</url>
            <title>Stories by Muratdayan on Medium</title>
            <link>https://medium.com/@muratdayan359?source=rss-36dbfa40b935------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 00:02:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@muratdayan359/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[Part 7 — State Durumunu Korumak]]></title>
            <link>https://medium.com/@muratdayan359/part-7-state-durumunu-korumak-00feedb0152f?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/00feedb0152f</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[state-management]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Thu, 21 Nov 2024 15:36:21 GMT</pubDate>
            <atom:updated>2024-11-21T15:36:21.178Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 7 — State Durumunu Korumak</h3><p>Selamlar , Jetpack Compose yazı serimizin bu partında UI State durumunu koruma işlemlerine bakacağız. Önceki partları incelemek isterseniz profilimden erişebilirsiniz. Hazırsanız başlayalım:)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fMOH79mogENh59l4.jpg" /></figure><p>State durumunu saklamak önemlidir çünkü uygulamamız bazı durumlarda state değerini kaybedebilir ve bu da kullanıcılara yanlış ve eksik bilgiler gösterimine neden olur. State hangi nedenlerle kaybolur;</p><p><em>1- Configuration Changes -&gt;</em> Dil değişikliği, yatay-dikey ekran çevirimleri manuel olarak yapılmadığında activity destroy olup yeniden oluşturulduğu için state durumu kaybolabilir.</p><p><em>2- System Initiated Process Death-&gt; </em>Uygulama arka planda çalıştığında sistem hafızayı diğer işlemlere ayırmak için state’i serbest bırakabilir.</p><p>Bu gibi durumlarda uygulamamızda tutmak isteyeceğimiz verilerin kaybolmamasını isteriz mesela buna örnek olarak bir listenin kaydırma konumu, kullanıcının hakkında daha fazla ayrıntı istediği öğenin id’si, kullanıcı tercihlerinin devam eden seçimi veya metin alanlarındaki inputlar örnek verilebilir.</p><p><strong>UI Logic</strong></p><p>Eğer State’iniz UI’da hoisted yapılmışsa rememberSaveable kullanarak bu state durumunu koruyabilirsiniz.</p><pre>@Composable<br>fun ChatBubble(<br>    message: Message<br>) {<br>    var showDetails by rememberSaveable { mutableStateOf(false) }<br><br>    ClickableText(<br>        text = AnnotatedString(message.content),<br>        onClick = { showDetails = !showDetails }<br>    )<br><br>    if (showDetails) {<br>        Text(message.timestamp)<br>    }<br>}</pre><p>Yukarıdaki örnekte <em>ClickableText’e </em>dokununca detay bilgisi olarak bir mesajın gönderilme saatini gösterip veya göstermeme işlemi kodlanmıştır. Burda rememberSaveable state durumunu bir Bundle’da tutar. Primitive tipler için bu yapı uygundur ama eğer Data Classlar gibi gelişmiş tipleri tutmak istiyorsanız Parcelize anotasyonu ile ListSaver, MapSaver gibi yapılar kullanabilirsiniz.</p><pre>@Composable<br>fun rememberLazyListState(<br>    initialFirstVisibleItemIndex: Int = 0,<br>    initialFirstVisibleItemScrollOffset: Int = 0<br>): LazyListState {<br>    return rememberSaveable(saver = LazyListState.Saver) {<br>        LazyListState(<br>            initialFirstVisibleItemIndex, initialFirstVisibleItemScrollOffset<br>        )<br>    }<br>}</pre><p>Yukarıdaki örnekte bir listenin kaydırma konumu rememberSaveable ile LazyListState.Saver fonksiyonu ile tutulmuştur. Bu fonksiyon, ekran döndürümü vs gibi configuration change işlemlerinde listenin konumunun tutulmasını ve kullanıcının tekrar bulunduğu konumdan listeyi görmesini sağlar.</p><p><strong>Best Practice</strong></p><p>rememberSaveable Bundle kullanır ama bu Bundle’ın boyutu sınırlıdır ve büyük nesnelerin depolanması Runtime’da TransactionTooLarge istisnalarına yol açabilir. Bu tür çökmeleri önlemek için, Bundle’da büyük ve karmaşık nesneler veya nesne listeleri saklamamalısınız. Bunun yerine id veya keyler saklanıp diğer büyük nesneler kalıcı depolama sağlayan mekanizmalar tarafından saklanmalıdır.</p><p><strong>Business Logic</strong></p><p>Eğer state’iniz viewmodel gibi yapılarda hoisted ediliyorsa viewmodel API’leri kullanılabilir. Bir configuration change olduğunda ve Activity yok edilip yeniden oluşturulduğunda, ViewModel’e çekilen State UI durumu bellekte tutulur. Yeniden oluşturulduktan sonra, eski ViewModel nesnesi yeni Activity nesnesine eklenir.</p><p>NOT: Ancak, bir ViewModel nesnesi sistem tarafından başlatılan işlem ölümünden(system initiated process death) sağ çıkmaz. UI durumunun bu durumdan etkilenmemesi için ViewModel için SavedStateHandle API’sini içeren Saved State modülünü kullanın.</p><p><strong>Best Practice</strong></p><p>SavedStateHandle’da Bundle mekanizmasını kullanır. Bu yüzden basit UI state’leri kaydetmelisiniz. Karmaşik ve büyük veri tutan state’leri burda saklamayıp kalıcı depolama sağlayan mekanizmalarda kullanmalısınız.</p><p><strong>SavedStateHandle APIs</strong></p><p>SavedStateHandle farkli apilere sahiptir.</p><p><strong>1-Compose State(saveable)</strong></p><p>UI öğesini MutableState olarak tutmak için SavedStateHandle’ın saveable apisini kullanın. Tıpkı rememberSaveable gibi Bundle’da sakladığı primitive tipleri alıp kullanabilirsiniz. Bir saver alarak bu işlemi yapar.Aşağıdaki örnekte kullanıcı her yazdığında message değişeni update edilir ve bundle’da savedStateHandle.saveable ile saklanır.</p><pre>class ConversationViewModel(<br>    savedStateHandle: SavedStateHandle<br>) : ViewModel() {<br><br>    var message by savedStateHandle.saveable(stateSaver = TextFieldValue.Saver) {<br>        mutableStateOf(TextFieldValue(&quot;&quot;))<br>    }<br>        private set<br><br>    fun update(newMessage: TextFieldValue) {<br>        message = newMessage<br>    }<br><br>    /*...*/<br>}<br><br>val viewModel = ConversationViewModel(SavedStateHandle())<br><br>@Composable<br>fun UserInput(/*...*/) {<br>    TextField(<br>        value = viewModel.message,<br>        onValueChange = { viewModel.update(it) }<br>    )<br>}</pre><p><strong>2- StateFlow(getStateFlow)</strong></p><p>StateFlow salt okunurdur ve API, yeni bir değeri flow yapmak (yaymak) üzere akışı değiştirebilmeniz için bir anahtar belirtmenizi gerektirir. Yapılandırdığınız anahtar ile StateFlow’u geri alabilir ve en son değeri toplayabilirsiniz(collect).</p><pre>private const val CHANNEL_FILTER_SAVED_STATE_KEY = &quot;ChannelFilterKey&quot;<br><br>class ChannelViewModel(<br>    channelsRepository: ChannelsRepository,<br>    private val savedStateHandle: SavedStateHandle<br>) : ViewModel() {<br><br>    private val savedFilterType: StateFlow&lt;ChannelsFilterType&gt; = savedStateHandle.getStateFlow(<br>        key = CHANNEL_FILTER_SAVED_STATE_KEY, initialValue = ChannelsFilterType.ALL_CHANNELS<br>    )<br><br>    private val filteredChannels: Flow&lt;List&lt;Channel&gt;&gt; =<br>        combine(channelsRepository.getAll(), savedFilterType) { channels, type -&gt;<br>            filter(channels, type)<br>        }.onStart { emit(emptyList()) }<br><br>    fun setFiltering(requestType: ChannelsFilterType) {<br>        savedStateHandle[CHANNEL_FILTER_SAVED_STATE_KEY] = requestType<br>    }<br><br>    /*...*/<br>}<br><br>enum class ChannelsFilterType {<br>    ALL_CHANNELS, RECENT_CHANNELS, ARCHIVED_CHANNELS<br>}</pre><p>Yukarıdaki örnekte savedStateHandle.getStateFlow apisine bir key ve başlangıç değeri veriyoruz. Sonra viewmodelimizde bu flowlanmış savedFilterType değişkenine emit ederek değerini gönderebiliyoruz.Kullanıcı her yeni filtre türü seçtiğinde setFiltering çağrılır. Bu, _CHANNEL_FILTER_SAVED_STATE_KEY adlı key’e saklanan SavedStateHandle’a yeni bir değer kaydeder. savedFilterType, key’e kaydedilen en son değeri yayan bir akıştır. filteredChannels, kanal filtrelemesini gerçekleştirmek için akışa abone olur.</p><p><strong>Özet</strong></p><p>Kullanılacak API, durumun nerede tutulduğuna ve gerektirdiği mantığa bağlıdır. UI mantığında kullanılan durum için rememberSaveable kullanın. İş mantığında kullanılan durum için, bunu bir ViewModel’de tutuyorsanız SavedStateHandle kullanarak kaydedin. Küçük miktarlarda UI durumunu saklamak için paket API’lerini (rememberSaveable ve SavedStateHandle) kullanmalısınız. Bu veriler, diğer saklama mekanizmalarıyla birlikte kullanıcı arayüzünü önceki durumuna geri döndürmek için gereken minimum değerdir. Örneğin, kullanıcının baktığı bir profilin ID’sini bundle’da saklarsanız, profil ayrıntıları gibi ağır verileri veri katmanından getirebilirsiniz.</p><p>Okuduğunuz İçin Teşekkürler:)</p><p>Bir sonraki partta görüşmek üzere:)</p><p><strong>Kaynakça</strong></p><p><a href="https://developer.android.com/develop/ui/compose/state-saving">https://developer.android.com/develop/ui/compose/state-saving</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00feedb0152f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part-6 State Hoist Mantığı]]></title>
            <link>https://medium.com/@muratdayan359/part-6-state-hoist-mant%C4%B1%C4%9F%C4%B1-46990132a1eb?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/46990132a1eb</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[state-hoisting]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Mon, 18 Nov 2024 11:22:15 GMT</pubDate>
            <atom:updated>2024-11-18T11:22:15.863Z</atom:updated>
            <content:encoded><![CDATA[<p>Selamlar ,</p><p>Jetpack Compose yazı serimizin 6.partıyla devam ediyoruz. Bu yazıda State-hoist işlemlerini nerde ve nasıl yapmalıyız bunu konuşacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0ptq0dv-suFb3T5O.png" /></figure><p><strong>Best Practice</strong></p><p>State durumunu , onu değiştiren veya kullanan composable fonksiyonlar için en alt parent olarak kullanmalısınız.</p><p><strong>UI State Türleri Ve Mantığı</strong></p><p><em>Screen UI State-&gt;</em> Sayfada gösterilecek bileşenlerin durumunu tutar.</p><p><em>UI Element State-&gt;</em> Android’de xmlde örneğin Textview’in setText ve getText gibi state durumları kendi içinde zaten kontrol edilebilir ama Compose’da biz state’i composable fonksiyondan ayırıp dışarıda state olarak tutabiliyoruz ve state holder gibi bir ana merkezden yönetebiliyoruz. Bu duruma Element State denilir.</p><p><strong>State Hoisting Her Zaman Gerekli Mi?</strong></p><p>Eğer bir state başka hiçbir composable fonksiyonda da kullanılmıyorsa buna ihtiyacımız yoktur.UI Element state’i composable fonksiyonların içinde tutmak kabul edilebilir. Uyguladığınız state ve mantık basitse ve UI hiyerarşisinin diğer bölümleri state’e ihtiyaç duymuyorsa bu iyi bir çözümdür. Örneğin, bu durum genellikle animasyon durumu için geçerlidir.</p><p><strong>Composable Fonksiyonlar İçinde Hoisting</strong></p><p>Birden çok composable fonksiyonda aynı state kulanılacaksa bu state’i daha yüksek bir parent’a kaldırmalıyız(hoisting).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jzpBLO-UtaHo2a0g.png" /></figure><p>Yukarıdaki Örnekte <em>JumpToBottom </em>listenin en aşağısını gösterir ve listenin state’ini değiştirecektir.Ayrıca kullanıcı her yeni mesaj gönderdiğinde de liste en aşağı kayacaktır bu da listenin state’ini değiştirecektir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G-5t4-RMmEtQaJff.gif" /></figure><p>Bu örneğin UI ağacını böyle varsayalım. LazyColumn’un state’i diğer composable fonksiyonlar tarafından da etkileneceği için Screen’e taşınır(hoisting). Bu örneğin kod kısmını aşağıya bırakıyorum.</p><pre>@Composable<br>private fun ConversationScreen(/*...*/) {<br>    val scope = rememberCoroutineScope()<br><br>    val lazyListState = rememberLazyListState() // Screen düzeyinde State Hoist<br><br>    MessagesList(messages, lazyListState) // MessagesList&#39;e state gönderimi<br><br>    UserInput(<br>        onMessageSent = { <br>            scope.launch {<br>                lazyListState.scrollToItem(0)<br>            }<br>        },<br>    )<br>}<br><br>@Composable<br>private fun MessagesList(<br>    messages: List&lt;Message&gt;,<br>    lazyListState: LazyListState = rememberLazyListState() // LazyListState default tanımlamaya sahiptir<br>) {<br><br>    LazyColumn(<br>        state = lazyListState // Lazy Column&#39;a state gönderimi<br>    ) {<br>        items(messages, key = { message -&gt; message.id }) { item -&gt;<br>            Message(/*...*/)<br>        }<br>    }<br><br>    val scope = rememberCoroutineScope()<br><br>    JumpToBottom(onClicked = {<br>        scope.launch {<br>            lazyListState.scrollToItem(0) // UI düzeyinde logic<br>        }<br>    })<br>}</pre><blockquote>NOT: LazyListState’in, default değeri rememberLazyListState() olarak MessagesList fonksiyonunda parametre alırken tanımlandığına dikkat edin. Bu, Compose’da yaygın bir modeldir. Composable fonksiyonları daha yeniden kullanılabilir ve esnek hale getirir. Daha sonra composable’ı uygulamanın durumu kontrol etmesi gerekmeyen farklı bölümlerinde kullanabilirsiniz.</blockquote><p><strong>State Holder Class</strong></p><p>Daha karmaşık UI işlemlerinde bu state görevleri bir state holder class’ına delege edilebilir. Bu kodumuzu daha temiz, kullanışlı ve test edilebilir yapar.(Seperation Of Concerns Princible).</p><p>Bu sınıflar, Composition’da oluşturulur ve hatırlanır. Composable’ın yaşam döngüsünü takip ettikleri için, rememberNavController() veya rememberLazyListState() gibi Compose kütüphanesi tarafından sağlanan türleri alabilirler. Yukarıdaki LazyListState’i bir class olarak tutsaydık aşağıdaki gibi olurdu.</p><pre>@Stable<br>class LazyListState constructor(<br>    firstVisibleItemIndex: Int = 0,<br>    firstVisibleItemScrollOffset: Int = 0<br>) : ScrollableState {<br>    /**<br>     *  listenin kaydırılma durumlarını tutan state holder class<br>     */<br>    private val scrollPosition = LazyListScrollPosition(<br>        firstVisibleItemIndex, firstVisibleItemScrollOffset<br>    )<br><br>    suspend fun scrollToItem(/*...*/) { /*...*/ }<br><br>    override suspend fun scroll() { /*...*/ }<br><br>    suspend fun animateScrollToItem() { /*...*/ }<br>}</pre><p>LazyListState , LazyColumn’un kaydırma durumlarını takip eden bir state holder class halindedir. Composable bileşenlerin sorumlulukları arttığında bu sorumlulukları bir state holder’a aktarmak iyi bir yoldur.</p><p><strong>ViewModel’da Business Logic State</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KDB86LugIgrjuNrd.png" /></figure><p>ViewModeller composition’un bir parçası değildir. Ama Yukarıdak örnekte yapıldığı gibi inputMessage state’ini viewmodelden Screen’e sağlayabiliriz. Bu durumda da bizim State Holder class’ımız viewmodel olur.(lowest common ancestor)(source of truth)</p><p><strong>Screen UI State</strong></p><p>Screen UI State’lerde bir state holder’da tutulabilir. Aşağıdaki örnekte Viewmodel üzerinden anlatalım.</p><pre>class ConversationViewModel(<br>    channelId: String,<br>    messagesRepository: MessagesRepository<br>) : ViewModel() {<br><br>    val messages = messagesRepository<br>        .getLatestMessages(channelId)<br>        .stateIn(<br>            scope = viewModelScope,<br>            started = SharingStarted.WhileSubscribed(5_000),<br>            initialValue = emptyList()<br>        )<br><br>    // Business logic<br>    fun sendMessage(message: Message) { /* ... */ }<br>}</pre><p>Bu örnekte yukarıdaki viewmodel’i Screen sayfanıza enjekte edebilir ve viewmodel içinde sakladığınız state değerlerini kullanabilirsiniz. Aşağıda viewmodel ConversationScreen’e enjekte edilmiş ve messages state olarak izlenip değerleri alınıyor.</p><pre>@Composable<br>private fun ConversationScreen(<br>    conversationViewModel: ConversationViewModel = viewModel()<br>) {<br><br>    val messages by conversationViewModel.messages.collectAsStateWithLifecycle()<br><br>    ConversationScreen(<br>        messages = messages,<br>        onSendMessage = { message: Message -&gt; conversationViewModel.sendMessage(message) }<br>    )<br>}<br><br>@Composable<br>private fun ConversationScreen(<br>    messages: List&lt;Message&gt;,<br>    onSendMessage: (Message) -&gt; Unit<br>) {<br><br>    MessagesList(messages, onSendMessage)<br>    /* ... */<br>}</pre><p><strong>Property Drilling</strong></p><p>Verilerin birkaç iç iç e composable fonksiyondan geçirilmesi anlamına gelir. Örneğin screen seviyesinde state tutup bunu alt composable bileşenlere aktarmak buna örnektir.</p><p>Eventleri paramatreler olarak almak Composable fonksiyonların sorumluluklarını bize en üst seviyede gösterir. Propert drilling bu parametrelerle sağlanmalı , wrapper classlar kullanmak karmaşıklığa yol açacaktır.</p><p><strong>UI Element State</strong></p><p>Chat app örneğini düşünelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/0*Whb1l8cS7SeXtxhk.png" /></figure><p>kullanıcı @ işaretine dokunup yazmaya başladığında kullanıcıya kişiler öneriliyor ve kullanıcı seçtiği kişiyi etiketleyebiliyor. Bu öneriler veri tabanından gelir ve business logic olarak görünür. Aşağıdaki viewmodel’da bu durumu nasıl yazabiliriz görüyoruz.</p><pre>class ConversationViewModel(/*...*/) : ViewModel() {<br><br>    // Hoisted yapılan state<br>    var inputMessage by mutableStateOf(&quot;&quot;)<br>        private set<br><br>    val suggestions: StateFlow&lt;List&lt;Suggestion&gt;&gt; =<br>        snapshotFlow { inputMessage }<br>            .filter { hasSocialHandleHint(it) }<br>            .mapLatest { getHandle(it) }<br>            .mapLatest { repository.getSuggestions(it) }<br>            .stateIn(<br>                scope = viewModelScope,<br>                started = SharingStarted.WhileSubscribed(5_000),<br>                initialValue = emptyList()<br>            )<br><br>    fun updateInput(newInput: String) {<br>        inputMessage = newInput<br>    }<br>}</pre><p>Örnekte inputMessage, TextField durumunu tutan bir değişkendir. Kullanıcı her yeni girdi yazdığında, uygulama öneriler üretmek için iş mantığını çağırır.</p><blockquote>NOT: Eğer bu değişken, kullanıcı önerileri üretmek için şu anda ihtiyaç duyulduğu gibi business logic için gerekli olmasaydı, screen seviyesinde bir state holder olarak yükseltilmemeliydi. UI’da tanımlanmalı ve saklanmalı, buna ihtiyaç duyan composable fonksiyona daha yakın olmalıydı.</blockquote><p><strong>Dikkat</strong></p><p>Viewmodel’deki state değişimleri sırasında bazı animasyon gibi işlemlerin cevap verme süresi olabilir bu durumu coroutine scopelarla dikkatli bir şekilde yönetmeliyiz.</p><p>Diyelim ki bir navigation drawer kullanıyosunuz ve bunun içeriği dinamik olarak açılıp ve kapatıldıktan sonra veri katmanından alıp yenilemeniz gerekiyor. Drawer state’ini ViewModel’e çekmelisiniz, böylece state holder olarak bu öğe üzerinde hem kullanıcı arayüzünü hem de iş mantığını çağırabilirsiniz. Ancak DrawerState’in close() yöntemini Compose UI’dan viewModelScope kullanarak çağırmak, “bu CoroutineContext’te bir MonotonicFrameClock mevcut değil” şeklinde bir mesajla IllegalStateException türünde bir hataya neden olur. Bunu düzeltmek için Composition’a kapsamlandırılmış bir CoroutineScope kullanın. Bu, CoroutineContext’te askıya alma işlevlerinin çalışması için gerekli olan bir MonotonicFrameClock sağlar.</p><blockquote>NOT: MonotonicFrameClock, Jetpack Compose&#39;da ve genel olarak Kotlin Coroutines&#39;de kullanılan bir zamanlayıcıdır. Monotonik zamanlayıcılar, zamanın sürekli ve kesintisiz olarak ilerlemesini garanti ederler, bu da özellikle animasyonlar ve zamanlama gerektiren görevler için önemlidir.</blockquote><p>Bu anlatılanı kod olarak incelemek isterseniz aşağıya bırakıyorum.</p><pre>class ConversationViewModel(/*...*/) : ViewModel() {<br><br>    val drawerState = DrawerState(initialValue = DrawerValue.Closed)<br><br>    private val _drawerContent = MutableStateFlow(DrawerContent.Empty)<br>    val drawerContent: StateFlow&lt;DrawerContent&gt; = _drawerContent.asStateFlow()<br><br>    fun closeDrawer(uiScope: CoroutineScope) {<br>        viewModelScope.launch {<br>            withContext(uiScope.coroutineContext) { // Default Context  yerine coroutine context kullanımı<br>                drawerState.close()<br>            }<br>            // Drawer içeriğini çekme ve güncelleme<br>            _drawerContent.update { content }<br>        }<br>    }<br>}<br><br><br>@Composable<br>private fun ConversationScreen(<br>    conversationViewModel: ConversationViewModel = viewModel()<br>) {<br>    val scope = rememberCoroutineScope()<br><br>    ConversationScreen(onCloseDrawer = { conversationViewModel.closeDrawer(uiScope = scope) })<br>}</pre><p><strong>Sonuç</strong></p><p>Bu yazıyla beraber bir state’in nerelerde nasıl hoist edilebileceğini ve best practice olarak neler yapılabileceğini konuştuk. State holder classları konuştuk. Bu yapılar uygulamamızın test edilebilirliğini, yeniden kullanılabilirliğini, karmaşıklığını, kod temizliğini düzenleyen yapılar olduğu için temiz bir mimari için dikkatle uygulanması gereken konulardır.</p><p>Okuduğunuz için teşekkürler:)</p><p>Bir daha ki yazıda görüşmek üzere!</p><p><strong>Kaynaklar</strong></p><p><a href="https://developer.android.com/develop/ui/compose/state-hoisting">https://developer.android.com/develop/ui/compose/state-hoisting</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46990132a1eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 5- State Ve Jetpack Compose]]></title>
            <link>https://medium.com/@muratdayan359/part-5-state-ve-jetpack-compose-5ed285b052cf?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ed285b052cf</guid>
            <category><![CDATA[state]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Fri, 15 Nov 2024 13:18:25 GMT</pubDate>
            <atom:updated>2024-11-15T13:18:25.567Z</atom:updated>
            <content:encoded><![CDATA[<p>Selamlar,</p><p>Bugünkü yazıda part 5&#39;te State konusunu genel bir bakış ile inceleyeceğiz. Önceki 4 partı okumak isterseniz profilimden inceleyebilirsiniz. Hadi başlayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/0*JGaKJP6UbqM1cL9-.png" /></figure><p>State kısaca uygulamanız içinde değişen durumlardır ve biz stateleri kullanarak uygulamamızın UI’ının bu değişen durumlara tepkiler vermesini sağlarız.</p><p><strong>State Ve Composition</strong></p><pre>@Composable<br>private fun HelloContent() {<br>    Column(modifier = Modifier.padding(16.dp)) {<br>        Text(<br>            text = &quot;Hello!&quot;,<br>            modifier = Modifier.padding(bottom = 8.dp),<br>            style = MaterialTheme.typography.bodyMedium<br>        )<br>        OutlinedTextField(<br>            value = &quot;&quot;,<br>            onValueChange = { },<br>            label = { Text(&quot;Name&quot;) }<br>        )<br>    }<br>}</pre><p>Eğer yukarıdaki kodu çalıştırıp TextField’a bişeyler yazdığımızda ekranda hiçbir şey olmadığını göreceğiz. Çünkü TextField kendini güncelleyemiyor.</p><p><strong>Composable Fonksiyonlarda State</strong></p><p>Composable fonksiyonlar bir bilgiyi depolamak için <strong><em>remember </em></strong>API kullanır. İlk Composition’da bu değer saklanır. Bu değer değiştirilebilir veya değiştirilemez olarak bellekte tutulabilir.</p><p><strong><em>Not</em></strong><em>: remember’i çağıran composable fonksiyon composition’dan çıkarıldığında remember bu nesneyi bilgiyi unutur.</em></p><p>remember kullanırken mutableStateOf kullanırız. Bu da;</p><pre>interface MutableState&lt;T&gt; : State&lt;T&gt; {<br>    override var value: T<br>}</pre><p>Şöyle bir interface’i arka planda çağırır.</p><p>3 tür remember tanımlama yolu vardır:</p><ul><li>val mutableState = remember { mutableStateOf(default) }</li><li>var value by remember { mutableStateOf(default) }</li><li>val (value, setValue) = remember { mutableStateOf(default) }</li></ul><p>by delegate’i getValue ve setValue değerlerini import eder ve state’i kullanırken .value diye yazdırmadan kullanabiliriz.</p><pre>@Composable<br>fun HelloContent() {<br>    Column(modifier = Modifier.padding(16.dp)) {<br>        var name by remember { mutableStateOf(&quot;&quot;) }<br>        if (name.isNotEmpty()) {<br>            Text(<br>                text = &quot;Hello, $name!&quot;,<br>                modifier = Modifier.padding(bottom = 8.dp),<br>                style = MaterialTheme.typography.bodyMedium<br>            )<br>        }<br>        OutlinedTextField(<br>            value = name,<br>            onValueChange = { name = it },<br>            label = { Text(&quot;Name&quot;) }<br>        )<br>    }<br>}</pre><p>İşte bu TextField’da remember state kullanarak artık kullanıcının yazdığı şeyi alıp kullanabilme imkanına ulaşıyoruz. Ayrıca composable fonksiyonlarda if gibi fonksiyonları da kullanıp şartlı gösterimler veya kodlar yazabiliyoruz.</p><p>NOT: remember, uygulama içi statedeğişikliklerinde fayda sağlarken configuration change’lerde(dil değişimi , yatay-dikey ekran) <strong><em>rememberSaveable </em></strong>kullanmalıyız.</p><p>NOT: ArrayList ve mutableListOf kullanımı state’te önerilmez.Veri kaybına neden olabilir. Bunun yerine değişmez olan List&lt;&gt; veya listOf kullanımı önerilir.</p><p><strong>Desteklenen Diğer State Türleri</strong></p><p>Compose Diğer State durumlarını da dinleme özelliğine sahiptir. Örneğin Flow-&gt; <a href="https://developer.android.com/reference/kotlin/androidx/lifecycle/compose/package-summary#extension-functions">collectAsStateWithLifecycle()</a> , <a href="https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary#(kotlinx.coroutines.flow.StateFlow).collectAsState(kotlin.coroutines.CoroutineContext)">collectAsState()</a></p><p>LiveData-&gt; <a href="https://developer.android.com/reference/kotlin/androidx/compose/runtime/livedata/package-summary#(androidx.lifecycle.LiveData).observeAsState(kotlin.Any)">observeAsState()</a></p><p>RxJava2 -&gt; <a href="https://developer.android.com/reference/kotlin/androidx/compose/runtime/rxjava2/package-summary#extension-functions">subscribeAsState()</a></p><p>RxJava3 -&gt; <a href="https://developer.android.com/reference/kotlin/androidx/compose/runtime/rxjava2/package-summary#extension-functions">subscribeAsState()</a></p><p>Değerin, Compose tarafından okunup recompose işlemleri için State&lt;&gt; değerine dönüşmesi gerekiyor. Bu yüzden observeAsState gibi extension fonksiyonlar kullanılmalıdır. Kendi extension fonksiyonumuzu da oluşturup state dinleme işlemlerini de yapabiliriz.</p><p><strong>StateFull vs Stateless</strong></p><p>remember yaparak kullandığımız fonksiyonlar statefull composable fonksiyonlardır. Bu statefull fonksiyonlarda durum state’e bağlıdır ve composable tüm süreci kendi yönetir.</p><p>Stateless composable fonksiyonlar ise , state’i dışardan parametre olarak alır. Daha fazla esneklik ve kontrol sağlar.Bu durumda <strong><em>stateHoisting </em></strong>kullanılır</p><p><strong>State Hoisting</strong></p><p>Dışardan parametre olarak alınan stateler kodumuzda Single Source Of Truth(SSoT), Encapsulation, Shareable, Interceptable ve Decoupled gibi kod prensibleri sağlar.</p><pre>@Composable<br>fun HelloScreen() {<br>    var name by rememberSaveable { mutableStateOf(&quot;&quot;) }<br><br>    HelloContent(name = name, onNameChange = { name = it })<br>}<br><br>@Composable<br>fun HelloContent(name: String, onNameChange: (String) -&gt; Unit) {<br>    Column(modifier = Modifier.padding(16.dp)) {<br>        Text(<br>            text = &quot;Hello, $name&quot;,<br>            modifier = Modifier.padding(bottom = 8.dp),<br>            style = MaterialTheme.typography.bodyMedium<br>        )<br>        OutlinedTextField(<br>           value = name,<br>           onValueChange = onNameChange,<br>           label = { Text(&quot;Name&quot;) })<br>    }<br>}</pre><p>Bu örnekte olduğu gibi name ve onValueChange değerlerini fonksiyonun parametresinden alıp ana Screen sayfamızdan call edebiliriz. Bu durumda HelloContent, tekrar tekrar kullanılabilir, test edilebilir ve daha esnektir.</p><p>Bu sayede biz Screen fonksiyonundan state’i gönderip HelloContent’den event’i alırız.</p><p>Böylece Undirectional Data Flow prensibini kullanarak tek yönlü veri akışı da sağlanmış olur. 3 anahtar kuralı dikkatlice bu durumda uygulamalıyız:</p><p>1- <strong>lowest common parent -&gt; </strong>Eğer birden fazla composable aynı state’i okuyorsa, bu state ortak bir parent fonksiyona taşınmalıdır. Bu, state’in her iki composable’a da erişilebilir olmasını sağlar.</p><p>2-<strong>highest level it may be changed -&gt; </strong>Eğer bir state birden fazla composable fonksiyon tarafından değiştiriliyorsa, bu state’in en yüksek parent fonksiyonda yönetilmesi gerekir. Böylece bu değişiklikler kontrol edilebilir hale gelir.</p><p>3- <strong>two states change in response to the same events -&gt;</strong>Eğer iki farklı state aynı olaylara tepki veriyorsa, bu state’ler birlikte üst parent fonksiyonda yönetilmelidir. Aksi takdirde, state’ler arasında tutarsızlık yaşanabilir.</p><p><strong>Compose State Geri Yükleme</strong></p><p>remembereSaveable api , remember gibi davranır ama configuration changelerde bile durumunu korur mesela ekran döndürülmesi gibi olaylarda kendini korur. Activity kullanıcı tarafından tamamen kaybedilirse durumunu korumaz bu duruma dikkat edilmelidir.</p><p><strong>State Depolama Yolları</strong></p><p>Bundle’a eklenen tüm veri türleri otomatik kaydedilir. Bundle’a eklenemeyen şeyleri nasıl kaydederiz:</p><p><strong><em>1-Parcelize</em></strong></p><pre>@Parcelize<br>data class City(val name: String, val country: String) : Parcelable<br><br>@Composable<br>fun CityScreen() {<br>    var selectedCity = rememberSaveable {<br>        mutableStateOf(City(&quot;Madrid&quot;, &quot;Spain&quot;))<br>    }<br>}</pre><p>Objemiz data class , parcelize anotasyonuyla parselize olabilme özelliği kazanıyor ve state olarak saklayabiliyoruz.</p><p><strong><em>2- MapSaver</em></strong></p><pre>data class City(val name: String, val country: String)<br><br>val CitySaver = run {<br>    val nameKey = &quot;Name&quot;<br>    val countryKey = &quot;Country&quot;<br>    mapSaver(<br>        save = { mapOf(nameKey to it.name, countryKey to it.country) },<br>        restore = { City(it[nameKey] as String, it[countryKey] as String) }<br>    )<br>}<br><br>@Composable<br>fun CityScreen() {<br>    var selectedCity = rememberSaveable(stateSaver = CitySaver) {<br>        mutableStateOf(City(&quot;Madrid&quot;, &quot;Spain&quot;))<br>    }<br>}</pre><p>Parcelize’nin uygun olmadığı durumlarda bir mapSaver fonksiyonu kullanıo save ve restore işlemlerini yapabiliriz.</p><p><strong><em>3- ListSaver</em></strong></p><pre>data class City(val name: String, val country: String)<br><br>val CitySaver = listSaver&lt;City, Any&gt;(<br>    save = { listOf(it.name, it.country) },<br>    restore = { City(it[0] as String, it[1] as String) }<br>)<br><br>@Composable<br>fun CityScreen() {<br>    var selectedCity = rememberSaveable(stateSaver = CitySaver) {<br>        mutableStateOf(City(&quot;Madrid&quot;, &quot;Spain&quot;))<br>    }<br>}</pre><p>key tanımlamaya ihtiyacımız yoksa ListSaver kullanabiliriz.</p><p><strong>State Holder In Compose</strong></p><p>state’lerimiz çoğalır ve yönetilmeyecek duruma gelirse State Holder sınıfı kullanmak iyi bir yoldur. Hoisted State Objects diye de anılır.</p><p><strong>Key Değiştiğinde Yeniden Tetikleme</strong></p><p>Genel olarak remember, bir calculation lambda parametresi alır. remember ilk çalıştırıldığında, calculation lambda’sını çağırır ve sonucunu depolar. recomposition sırasında remember, son depolanan değeri döndürür.</p><pre>val brush = remember {<br>    ShaderBrush(<br>        BitmapShader(<br>            ImageBitmap.imageResource(res, avatarRes).asAndroidBitmap(),<br>            Shader.TileMode.REPEAT,<br>            Shader.TileMode.REPEAT<br>        )<br>    )<br>}</pre><p>Yukarıdaki örnek bir remember kullanımı için maliyetli bir örnektir. remember api, key veya keys parametresi alır. Eğer key’lerden biri değişirse remember saklanan değeri geçersiz kılar ve lambda bloğunu tekrar çalıştırır. Bu da bize daha fazla kontrol almamızı sağlar.</p><pre>@Composable<br>private fun BackgroundBanner(<br>    @DrawableRes avatarRes: Int,<br>    modifier: Modifier = Modifier,<br>    res: Resources = LocalContext.current.resources<br>) {<br>    val brush = remember(key1 = avatarRes) {<br>        ShaderBrush(<br>            BitmapShader(<br>                ImageBitmap.imageResource(res, avatarRes).asAndroidBitmap(),<br>                Shader.TileMode.REPEAT,<br>                Shader.TileMode.REPEAT<br>            )<br>        )<br>    }<br><br>    Box(<br>        modifier = modifier.background(brush)<br>    ) {<br>        /* ... */<br>    }<br>}</pre><p>Yukarıdaki örnekte avatarRes değeri key olarak tutulur ve bu değer değiştiğinde Image’in arka planı tekrar oluşturulur.</p><pre>@Composable<br>private fun rememberMyAppState(<br>    windowSizeClass: WindowSizeClass<br>): MyAppState {<br>    return remember(windowSizeClass) {<br>        MyAppState(windowSizeClass)<br>    }<br>}<br><br>@Stable<br>class MyAppState(<br>    private val windowSizeClass: WindowSizeClass<br>) { /* ... */ }</pre><p>Yukarıdaki örnekte ise cihaz döndürülmesi gibi bir olay olduğunda windowSizeClass değişir ve MyAppState yeniden oluşturulur.</p><p>NOT: Compose, bir keyin değişip değişmediğine karar vermek ve depolanan değeri geçersiz kılmak için sınıfın <strong><em>equals </em></strong>fonksiyonunu kullanır.</p><h3>RememberSaveAble’da Inputlar</h3><p>rememberSaveable API, verileri bir Bundle’da saklayabilen remember’ın etrafındaki bir sarmalayıcıdır. Bu API, state’in yalnızca recompositiondan değil, aynı zamanda Activity yeniden oluşturma ve ve sistemin ölümünden de kurtulmasını sağlar. rememberSaveable, remember’ın keyleri almasıyla aynı amaçla input parametrelerini alır. İnputlardan herhangi biri değiştiğinde önbellek geçersiz kılınır. İşlev bir sonraki sefer recompositionda, rememberSaveable hesaplama lambda bloğunu yeniden yürütür.</p><pre>var userTypedQuery by rememberSaveable(typedQuery, stateSaver = TextFieldValue.Saver) {<br>    mutableStateOf(<br>        TextFieldValue(text = typedQuery, selection = TextRange(typedQuery.length))<br>    )<br>}</pre><p>Yukarıdaki örnekte rememberSaveable, typedQuery değişene kadar userTypedQuery öğesini saklar.</p><p><strong>Sonuç</strong></p><p>State kullanmak işlerimizi çok kolaylık sağlarken eğer doğru kullanırsak bize maliyet ve performans kazancı da sağlayacağı için çok önemli ve dikkatlice uygulanması gereken bir işlemdir.</p><p>Okuduğunuz İçin Teşekkürler:)</p><p>Bir sonraki yazımızda görüşmek üzere!</p><p><strong>Kaynaklar</strong></p><p><a href="https://developer.android.com/develop/ui/compose/state">https://developer.android.com/develop/ui/compose/state</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ed285b052cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 4 — Compose Phases]]></title>
            <link>https://medium.com/@muratdayan359/part-4-compose-phases-8800f089df79?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/8800f089df79</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[compose-ui]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Wed, 17 Jul 2024 17:21:11 GMT</pubDate>
            <atom:updated>2024-07-17T17:21:11.329Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 4 — Compose Phases</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yknUCWShRkcHSupm9y5rtA.png" /></figure><p>Merhabalar , yazı serimizin 4.partıyla devam ediyoruz. Bugünkü konumuz compose’un ekrana çizim fazları olacak.</p><p>Hadi başlayalım.</p><p>Bileşenleri ekrana çizdirirken viewlarda 3 faz var. Measure(ölçekleme),layout ve drawing. Compose’da bu 3 faza artı olarak composition fazı vardır. Measure fazı Layout fazı içinde gerçekleşiyor.</p><p><strong>3 Ana Faz</strong></p><p><strong>Composition</strong>:Composable fonksiyonlar çalışır ve UI düzeneği belirlenir.</p><p><strong>Layout</strong>: Measurement ve placement adında 2 fazdan oluşur. Bileşenlerin 2d koordinatlarda yeri belirlenir ve ölçeklenir.</p><p><strong>Drawing</strong>: Bileşenler bir UI ekranı gibi davranan canvas öğesine çizilir.</p><blockquote>Undirectional Data Flow: Bu fazların sırası genellikle aynıdır; verilerin compositiondan çizime kadar tek yönde akarak bir çerçeve oluşturmasına olanak tanır (tek yönlü veri akışı olarak da bilinir).</blockquote><p><strong>Composition</strong></p><p>Bu fazda compose , composable fonksiyonları çalıştırır ve UI ağacını oluşturur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*rzzbQUST0mWIaIG9wm8m0w.png" /><figcaption>UI Ağacı</figcaption></figure><p>Yukarıdaki resmi incelersek composable her bir fonksiyon ağacın dalları gibi görünür ve yukarıdan aşağıya doğru ağacı oluşturmaya başlar.</p><p><strong>Layout</strong></p><p>Layout fazında UI ağacına göre her düğümün boyutuna ve 2D uzaydaki boşluğa göre konumuna karar verilir. Aşağıdaki temel 3 adıma göre algoritması çalıştırılır.</p><p>1-Measure Children: Düğüm varsa child(alt dalları) ölçülür.</p><p>2-Decide Own Size: Bu child bileşenlere bakılarak düğüm kendi boyutuna karar verir.</p><p>3-Place Children: Her child, kendi düğümüne göre konumu belirlenir.</p><p>Bu işlemlerden sonra her bir düğümün genişliği, yüksekliği ve çizilmesi gereken yerde bir x,y koordinatı vardır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KIt5VCSjVh0i0oO9hAwq_g.png" /><figcaption>Layout</figcaption></figure><p>Buna göre yukarıdaki ağacı anlatalım:</p><p>1- Row bileşeninin child bileşenlerine yani Image ve Column bileşenleri ölçülür.</p><p>2- Image ölçüldü.Image’nin child bileşeni yok ve kendi boyutuna karar verir ve Row’a bildirir.</p><p>3- Column’un child bileşenleri olduğu için önce o bileşenlere geçilir.</p><p>4- Önce Text bileşeni ölçüldü, child bileşenleri yok ve boyutunu belirler ve Column’a bildirir. İkinci Text bileşeni de aynı şekilde tekrarlanır.</p><p>5- Column, child bileşenlerinin boyutlarına göre kendi kendi boyutunu ayarlar, child bileşenlerinin max genişlik ve yükseklik bilgisine göre bu işlemi yapar.</p><p>6- Column, daha sonra child bileşenlerini kendi içinde dikey olarak alt alta yerleştirir.</p><p>7-Row, Image ve Column bileşenlerinin boyutlarına göre kendi boyutunu ayarlar ve daha sonra bu child bileşenlerini yatay olarak kendi alanında yerleştirir.</p><blockquote>NOT: Her düğüm bir kez tekrar edilir. ağacın boyutuna göre bu gezinme işlemi doğrusal olarak artar. Buna karşın her düğüm birden fazla kez ziyaret edilirse bu da uygulamamızı çok yavaşlatır.</blockquote><p><strong>Drawing</strong></p><p>Drawing fazında UI ağacı yine yukarıdan aşağıya doğru izlenir ve her düğüm kendini ekrana çizdirir. Pikseller ekrana çizilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jthze_0QxMvwljAjPyZGSQ.png" /><figcaption>Drawing</figcaption></figure><p><strong>State Kullanımı</strong></p><p>State genellikle mutableStateOf() kullanılarak oluşturulur ve daha sonra iki yoldan biriyle erişilir: doğrudan value özelliğine erişerek veya alternatif olarak bir Kotlin property delegate kullanarak.</p><pre>// State&#39;in value özelliği ile kullanılması<br>val paddingState: MutableState&lt;Dp&gt; = remember { mutableStateOf(8.dp) }<br>Text(<br>    text = &quot;Hello&quot;,<br>    modifier = Modifier.padding(paddingState.value)<br>)</pre><pre>// State&#39;in property delegate ile kullanılması<br>var padding: Dp by remember { mutableStateOf(8.dp) }<br>Text(<br>    text = &quot;Hello&quot;,<br>    modifier = Modifier.padding(padding)<br>)</pre><p>Yukarıdaki 2 yolla da state’in setter ve getter metodlarına ulaşırız.O yüzden benzerdir diyebiliriz.</p><p><strong>Compose Fazlarında State</strong></p><p>Yukarıda bahsettiğimiz 3 fazda da compose, stateleri izler.</p><blockquote>NOT: State’in oluşturulduğu yerin fazlar üzerinde etkisi yoktur, önemli olan ne zaman ve nerede statein okunduğudur.</blockquote><p><strong>Faz 1: Composition</strong></p><p>Composition yapılırken statein değişmesi diğer fazları da etkiler. State değeri değiştiğinde state’ten etkilenen tüm composable fonksiyonlar tekrardan çalışma sırasına konulur. Bu çalışma zamanında girdiler değişmemişse composable fonksiyonların bazılarını veya tamamını atlayabileceğini unutmayın.Compositionun sonucuna bağlı olarak Compose UI, layout ve drawing fazlarını çalıştırır. İçerik aynı kalırsa ve boyut ve düzen değişmeyecekse bu fazlar atlanabilir.</p><pre>var padding by remember { mutableStateOf(8.dp) }<br>Text(<br>    text = &quot;Hello&quot;,<br>    // Compositionda state okunur ve state değeri değiştiğinde <br>    // Modifier tekrardan bileşeni düzenlemeye başlar.<br>    modifier = Modifier.padding(padding)<br>)</pre><p><strong>Faz 2: Layout</strong></p><p>Layout fazı measurement ve placement adımlarından oluşuyordu. Measurement adımında MeasureScope.measure vb… ,Placement adımında ise Modifier.offset{…} gibi fonksiyonlar çalışır. State bu adımlarda okunduğunda measurement veya placement adımları çalışır. Yani daha açıkça measurement ve placement ayrı ayrı yeniden başlatma işlevlerine sahiptirler ve state’e göre bileşenin boyutunu veya düzenini değiştirebilirler.</p><p><strong>Faz 3: Drawing</strong></p><p>Compose Drawing fazında da state’i okuyup çizimi tekrardan başlatabilir. Modifier.drawBehind() veya Modifier.drawRect() gibi fonksiyonlar kullanılır.</p><pre>var color by remember { mutableStateOf(Color.Red) }<br>Canvas(modifier = modifier) {<br>    // color state&#39;ine göre çizim tekrardan başlatılır.<br>    drawRect(color)<br>}</pre><p><strong>State Okunmasının Optimize Edilmesi</strong></p><pre>Box {<br>    val listState = rememberLazyListState()<br><br>    Image(<br>        // ...<br>        // Optimum olmayan kod yazımı!<br>        Modifier.offset(<br>            with(LocalDensity.current) {<br>                // firstVisibleItemScrollOffset statei her seferinde okunur<br>                (listState.firstVisibleItemScrollOffset / 2).toDp()<br>            }<br>        )<br>    )<br><br>    LazyColumn(state = listState) {<br>        // ...<br>    }<br>}</pre><p>Bu kod çalışır ama optimum edilebilir. Kod firstVisibleItemScrollOffset state’inin değerini okur ve offset’e yazdırır. Kullanıcı kaydırdıkça firstVisibleItemScrollOffset değeri değişecek ve compose bu durumu her seferinde okuyacak. Bu okumada Box() fonksiyonu yeniden değerlenecek, ölçülecek ve çizilecek bu da uygulamada optimumluğu bize sağlamayacak. Değer değişmese bile her kaydırmada Composa fazları tetiklenecektir.Bu kodu yeniden düzenleyerek sadece Layout fazını tetikleyecek şekilde düzeltebiliriz.</p><pre>Box {<br>    val listState = rememberLazyListState()<br><br>    Image(<br>        // ...<br>        Modifier.offset {<br>            // Layout fazında FirstVisibleItemScrollOffset stateinin okuması<br>            IntOffset(x = 0, y = listState.firstVisibleItemScrollOffset / 2)<br>        }<br>    )<br><br>    LazyColumn(state = listState) {<br>        // ...<br>    }<br>}</pre><p>Yukarıdaki kod daha performanslı çalışır neden? Modifier’a sağladığımız labmda bloğu sayesinde state sadece Layout fazının placement aşamasında okunur. bu sayede state değeri değişirse bile sadece Layout ve Drawing fazları çalışacaktır.</p><p>Yani state okumaları mümkünce en az fazda gerçekleşmelidir.</p><p><strong>Recomposition Döngüsü</strong></p><p>Compose fazları her zaman aynı sırada gerçekleşir ve geriye doğru gidilmez demiştik bu da bize bir recomposition döngü sorunu çıkarabilir.</p><pre>Box {<br>    var imageHeightPx by remember { mutableStateOf(0) }<br><br>    Image(<br>        painter = painterResource(R.drawable.rectangle),<br>        contentDescription = &quot;ben Text&#39;in üstündeyim&quot;,<br>        modifier = Modifier<br>            .fillMaxWidth()<br>            .onSizeChanged { size -&gt;<br>                // aşağıdaki satırı yapma!!<br>                imageHeightPx = size.height<br>            }<br>    )<br><br>    Text(<br>        text = &quot;ben Image&#39;nin altındayım&quot;,<br>        modifier = Modifier.padding(<br>            top = with(LocalDensity.current) { imageHeightPx.toDp() }<br>        )<br>    )<br>}</pre><p>Burada (kötü bir şekilde) Column kodu uyguladık, en üstte Image() ve altında Text() var. Resmin çözümlenmiş boyutunu bilmek için Modifier.onSizeChanged() kullanıyoruz ve ardından aşağı kaydırmak için metin üzerinde Modifier.padding() kullanıyoruz. Px’den Dp’ye doğal olmayan geri dönüşüm zaten kodda bir sorun olduğunu gösteriyor.</p><p>Hadi kodu açıklayalım.</p><p>ilk frame(aşamada) imageHeightPx değeri sıfırdır ve Text()’in padding değeri sıfır olur. Ardından Layout fazına geçilir ve onSizeChanged için geri tetiklenme olur. bu imageHeightPx değerinin , resmin gerçek yüksekliğine güncellendiği an oluyor.Sonra bir sonraki frame için tekrar composition oluyor.Drawing fazında bu değer değişikliği henüz yansıtılmadığı için Text()’in padding değeri sıfırda kalır ve uygulamada bileşenlerimiz saçma şekilde görünebilir.</p><p>Compose daha sonra imageHeightPx için değer değişikliğini yansıtmak için tekrar frame başlatır. State Box() içinde okunur ve Text()’in padding değeri görüntü yüksekliğiyle aynı olur. Layout aşamasında imageHeightPx değeri tekrar ayarlanır ancak değer aynı olduğu için recomposition planlanmaz. Sonunda Text() padding’i değeri doğru ayarlanır ancak fazladan frame planlanmış oldu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VDcPVLXHXrqMm2k54F__ZA.png" /><figcaption>Yukarıdaki yazının resimle anlatımı</figcaption></figure><p><strong>Modifier.onSizeChanged(), onGloballyPositioned(), veya Diğer Layout İşlemleri:</strong></p><ul><li>Bu işlemler, UI bileşenlerinin boyutları veya konumları değiştiğinde çağrılır. Örneğin, Modifier.onSizeChanged() bileşenin boyutu her değiştiğinde tetiklenir ve boyut bilgilerini sağlar. Modifier.onGloballyPositioned() ise bileşenin ekrandaki global konumunu belirler.</li><li>Bu bilgiler, UI’nin nasıl düzenlendiği konusunda önemli ipuçları verir, ancak bu bilgileri almak ve ardından durumu güncellemek, yerleşim döngülerine ve karmaşıklıklara neden olabilir.</li></ul><p><strong>State Güncellemesi ve Bu State’i Modifier Olarak Kullanmak:</strong></p><ul><li>Yukarıdaki adımlardan elde edilen bilgilerle bir state’i güncelleyip bu durumu bir layout modifier (örn. padding(), height()) olarak kullanmak, placement hesaplamalarını ve güncellemelerini tetikleyebilir.</li><li>Bu durum, UI’nin sürekli olarak yeniden düzenlenmesine ve performans sorunlarına yol açabilir.</li></ul><p><strong>Tekrar Eden Döngüler:</strong></p><ul><li>Bu sürecin sürekli tekrarlanması, sonsuz döngülere veya beklenmedik yerleşim davranışlarına neden olabilir. Bu, uygulamanın kararlılığını ve performansını olumsuz etkileyebilir.</li></ul><p><strong>Sonuç</strong></p><p>Compose’un fazlarını ve state kullanımını anlamak, daha verimli ve performanslı UI bileşenleri oluşturmanıza yardımcı olur. Bu yazıda, Compose’da bileşenlerin nasıl ölçeklendirildiğini, yerleştirildiğini ve çizildiğini inceledik. Ayrıca, state kullanımının optimizasyonu ve recomposition döngüleri üzerinde durduk.</p><p>Bir sonraki yazımızda görüşmek üzere!</p><p><strong>Kaynaklar</strong></p><p><a href="https://developer.android.com/develop/ui/compose/phases">https://developer.android.com/develop/ui/compose/phases</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8800f089df79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 3 — Side Effects]]></title>
            <link>https://medium.com/@muratdayan359/part-3-side-effects-b895bfd080f0?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/b895bfd080f0</guid>
            <category><![CDATA[composition]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[side-effects]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Sat, 13 Jul 2024 11:44:48 GMT</pubDate>
            <atom:updated>2024-07-13T11:44:48.300Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 3 — Side Effects</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_xO5y4phJFamZFd4pXfMwg.png" /></figure><p>Selamlar</p><p>Part 3 ile devam ediyoruz. Daha önceki yazılarda sürekli bahsettiğimiz side-effect konusuna derinlemesine bakalım. İyi Okumalar:)</p><blockquote>NOT: Önceki partları okumak isteyenler aşağıdaki linklerden ulaşabilir.</blockquote><p>Part 1-&gt; <a href="https://medium.com/@muratdayan359/part-1-compose-gibi-d%C3%BC%C5%9F%C3%BCnmek-d37e16f4d675">https://medium.com/@muratdayan359/part-1-compose-gibi-d%C3%BC%C5%9F%C3%BCnmek-d37e16f4d675</a></p><p>Part 2 -&gt;<a href="https://medium.com/@muratdayan359/part-2-composeda-lifecycle-0f57658ed81f">https://medium.com/@muratdayan359/part-2-composeda-lifecycle-0f57658ed81f</a></p><p>Hazırsanız başlayalım:)</p><p>Side effect’ler composable fonksiyonların bloğunun dışında yazılması önerilen kod işlemleridir diyebiliriz. Recomposition’u etkileyen kodlardır.Fakat bazen composable fonksiyonların kapsamında da yazılabilir. Bu durumda aşağıdaki yapıları kullanarak durumu daha kontrollü ve akıllı yönetebiliriz.</p><blockquote><strong>Effect</strong>: UI oluşturmayan ve kompozisyon tamamlandığında yan etkileri çalıştıran bir composable fonksiyondur.</blockquote><p><strong>LaunchedEffect</strong></p><p>Coroutine yapısıyla beraber asenkron fonksiyonları çağırmada kullanılan bir composable fonksiyondur. LaunchedEffect compositiona girdiğinde coroutine işlemini başlatır. İçerdiği keylerle , durumu değişirse her seferinde coroutine işlemini iptal edip tekrar recomposition’a girebilir ve coroutine işlemlerini de kendi yaşam döngüsü gibi iptal edip tekrardan başlatabilir.</p><pre>var pulseRateMs by remember { mutableStateOf(3000L) }<br>val alpha = remember { Animatable(1f) }<br>LaunchedEffect(pulseRateMs) { // pulseRateMs değiştiğinde tekrar başlatılır<br>    while (isActive) {<br>        delay(pulseRateMs) // geciktirir<br>        alpha.animateTo(0f)<br>        alpha.animateTo(1f)<br>    }<br>}</pre><p>Yukarıdaki kodda delay suspend fonksiyonu kullanılır.sonra animasyon işlemleri yapılır. bu composable’ın yaşam döngüsü boyunca tekrarlanabilir.</p><blockquote>NOT:LaunchedEffect bir composable fonksiyon olduğu için, yalnızca diğer composable fonksiyonlar içinde kullanılabilir.</blockquote><p><strong>rememberCoroutineScope</strong></p><p>LaunchedEffect’ten farklı olarak bir composable fonksiyonun dışında bir coroutine işlemini başlatmamızı ve manuel olarak kontrol etmemizi sağlayan yapıdır.</p><pre>@Composable<br>fun MoviesScreen(snackbarHostState: SnackbarHostState) {<br><br>    // MoviesScreen()&#39;in yaşam döngüsüne bağlı bir rememberCoroutineScope <br>    val scope = rememberCoroutineScope()<br><br>    Scaffold(<br>        snackbarHost = {<br>            SnackbarHost(hostState = snackbarHostState)<br>        }<br>    ) { contentPadding -&gt;<br>        Column(Modifier.padding(contentPadding)) {<br>            Button(<br>                onClick = {<br>                    // scope ile manuel kontrol ettiğimiz coroutine blok <br>                    scope.launch {<br>                        snackbarHostState.showSnackbar(&quot;Butona tıklandı!&quot;)<br>                    }<br>                }<br>            ) {<br>                Text(&quot;Tıkla bana&quot;)<br>            }<br>        }<br>    }<br>}</pre><p>Bu örnekte, kullanıcı bir butona tıkladığında snackbar gösterilir ve coroutine scope kullanılarak coroutine başlatılır.</p><p><strong>rememberUpdatedState</strong></p><p>LaunchedEffect keylerden biri değiştiğinde yeniden işlem başlatırdı. Ama bazen bir değeri almak isteriz ve bu değer değiştiğinde efektin yeniden başlamasını istemeyiz.Bu durumlarda, rememberUpdatedState fonksiyonu devreye girer. rememberUpdatedState, bir değere referans oluşturmak ve composable fonksiyonun ömrü boyunca bu değeri korumak için kullanılır.</p><pre>@Composable<br>fun LandingScreen(onTimeout: () -&gt; Unit) {<br><br>    // timeout referansına tutar<br>    val currentOnTimeout by rememberUpdatedState(onTimeout)<br><br>    // timeout referansına göre recomposition yapılabilir<br>    LaunchedEffect(true) {<br>        delay(SplashWaitTimeMillis)<br>        currentOnTimeout()<br>    }<br><br>    <br>}</pre><p>Verilen kod örneğinde LandingScreen composable fonksiyonu, onTimeout parametresini alır. Bu parametre, belirli bir süre sonra çalıştırılacak bir fonksiyondur. LandingScreen fonksiyonu ilk kez oluşturulduğunda veya onTimeout parametresinde bir değişiklik olduğunda LaunchedEffect tetiklenir.</p><p>LaunchedEffect içerisinde delay(SplashWaitTimeMillis) fonksiyonu kullanılır. Bu fonksiyon, SplashWaitTimeMillis kadar gecikme oluşturur. Bu gecikme süresi boyunca LandingScreen composable fonksiyonu yeniden oluşturulsa bile LaunchedEffect tetiklenmez.</p><p>Bunun sebebi, rememberUpdatedState fonksiyonu ile onTimeout parametresine referans oluşturulmasıdır. LaunchedEffect içerisinde kullanılan currentOnTimeout değişkeni, rememberUpdatedState ile yakalanan onTimeout parametresine referans verir. Bu sayede, onTimeout parametresinde bir değişiklik olsa bile currentOnTimeout değişkeni güncellenir ve LaunchedEffect tetiklenmez.</p><p><strong>DisposableEffect</strong></p><p>Key değiştiğinde veya composable fonksiyonumuz compositiondan çıktığında (genelde clean işlemleri) bir iş yapıyorsa, DisposableEffect kullanılır.Örneğin, bir ağ bağlantısını kapatmak, bir dosya işlemini sonlandırmak veya bir gözlemciyi kaydetmeyi iptal etmek gibi işlemler için kullanılabilir.</p><pre>@Composable<br>fun HomeScreen(<br>    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,<br>    onStart: () -&gt; Unit, // &#39;Başlatıldı&#39; analitik olayını gönderen lamba<br>    onStop: () -&gt; Unit // &#39;Durduruldu&#39; analitik olayını gönderen lambda<br>) {<br>    // Yeni bir lambda değeri sağlandığında güncellenir<br>    val currentOnStart by rememberUpdatedState(onStart)<br>    val currentOnStop by rememberUpdatedState(onStop)<br><br>    // `lifecycleOwner` değişirse, etkiyi atın ve sıfırlayın<br>    DisposableEffect(lifecycleOwner) {<br>        // Analitik olayları göndermek için hatırlanan geri çağrılarımızı tetikleyen bir gözlemci oluştur<br>        val observer = LifecycleEventObserver { _, event -&gt;<br>            if (event == Lifecycle.Event.ON_START) {<br>                currentOnStart()<br>            } else if (event == Lifecycle.Event.ON_STOP) {<br>                currentOnStop()<br>            }<br>        }<br><br>        // Gözlemciyi yaşam döngüsüne ekle<br>        lifecycleOwner.lifecycle.addObserver(observer)<br><br>        // Etki kompozisyondan çıktığında gözlemciyi kaldır<br>        onDispose {<br>            lifecycleOwner.lifecycle.removeObserver(observer)<br>        }<br>    }<br><br>    <br>}</pre><ul><li><strong>Zorunlu onDispose:</strong> DisposableEffect içerisinde her zaman onDispose bloğu bulunmalıdır.</li><li><strong>Boş onDispose’den Kaçının:</strong> onDispose bloğunda yapılacak temizlik işlemi yoksa, farklı bir etki türü kullanmayı veya kodunuzu yeniden düzenlemeyi düşünün.</li><li><strong>Key Bazlı Temizleme:</strong> Key değiştiğinde etki atılır ve yeniden oluşturulur.</li></ul><p><strong>SideEffect</strong></p><p>Compose durumu ile Compose tarafından yönetilmeyen nesneler arasında iletişim kurmak için SideEffect kullanılır. Bu, her başarılı recomposition işleminden sonra side-effect kodların çalıştırılmasını garanti eder.</p><pre>@Composable<br>fun rememberFirebaseAnalytics(user: User): FirebaseAnalytics {<br>    val analytics: FirebaseAnalytics = remember {<br>        FirebaseAnalytics()<br>    }<br><br>    // her başarılı composition&#39;dan sonra firebase analytics&#39;e kullanıcı türü bilgisi gönderilir<br>    SideEffect {<br>        analytics.setUserProperty(&quot;userType&quot;, user.userType)<br>    }<br>    return analytics<br>}</pre><p><strong>produceState</strong></p><p>produceState Jetpack Compose&#39;da, composition kapsamında bir coroutine başlatarak, döndürülen bir State nesnesine değerler iten bir fonksiyondur. Non-Compose durumunu Compose durumuna dönüştürmek için kullanılır.</p><ul><li><strong>Coroutine Başlatma:</strong> produceState compositiona girdiğinde bir coroutine başlatır ve composition sona erdiğinde bu coroutine iptal edilir.</li><li><strong>State Oluşturma:</strong> Döndürdüğü State nesnesi, aynı değerin tekrar atanması durumunda recomposition tetiklemez (conflate davranışı).</li><li><strong>Veri Güncelleme:</strong> Coroutine içerisinde veriler yüklendiğinde veya değiştiğinde, value değişkeni kullanılarak State nesnesinin değeri güncellenir. Bu, State nesnesini kullanan yerlerde recompositiona neden olur.</li></ul><pre>@Composable<br>fun loadNetworkImage(<br>    url: String,<br>    imageRepository: ImageRepository = ImageRepository()<br>): State&lt;Result&lt;Image&gt;&gt; {<br><br>    // Başlangıç değeri olarak Result.Loading olan bir State&lt;T&gt; oluşturur<br>    // url veya imageRepository değişirse, çalışan producer iptal edilir ve yeni girişlerle yeniden başlatılır.<br>    return produceState&lt;Result&lt;Image&gt;&gt;(initialValue = Result.Loading, url, imageRepository) {<br><br>        // Bir coroutine içinde askıya alınabilir çağrılar yapabiliriz<br>        val image = imageRepository.load(url)<br><br>        // State&#39;i Error veya Success sonucu ile güncelle.<br>        // Bu, bu State&#39;in okunduğu yerde bir yeniden oluşturmaya tetikler<br>        value = if (image == null) {<br>            Result.Error<br>        } else {<br>            Result.Success(image)<br>        }<br>    }<br>}</pre><blockquote>Dönüş türüne sahip composable fonksiyonlar, normal bir Kotlin fonksiyonunu adlandırdığımız şekilde, küçük harfle başlayarak adlandırılmalıdır.</blockquote><p><strong>derivedStateOf</strong></p><p>State gerektiğinden fazla değişiyorsa her seferinde composable fonksiyonu recomposition yapmaya gerek yoksa derivedStateOf kullanırız. derivedStateOf, yalnızca ihtiyacımız olduğu kadar güncellenen, gözlemleyebileceğimiz yeni bir Compose state nesnesi oluşturur.</p><blockquote>Dikkat: derivedStateOf maliyetlidir ve yalnızca bir sonuç değişmediğinde gereksiz recompositionu önlemek için kullanmalısınız.</blockquote><pre>@Composable<br>// messages parametresi değişse bile derivedStateOf MessageList&#39;in recomposition edilmesini önler<br>fun MessageList(messages: List&lt;Message&gt;) {<br>    Box {<br>        val listState = rememberLazyListState()<br><br>        LazyColumn(state = listState) {<br>            // ...<br>        }<br><br>        <br>        val showButton by remember {<br>            derivedStateOf {<br>                listState.firstVisibleItemIndex &gt; 0<br>            }<br>        }<br><br>        AnimatedVisibility(visible = showButton) {<br>            ScrollToTopButton()<br>        }<br>    }<br>}</pre><p>Bu kod parçasında,listenin ilk ögesi her değiştiğinde firstVisibleItemIndex değişir. Siz kaydırdıkça değer 0, 1, 2, 3, 4, 5 vb. olur. Ancak, recomposition işleminin yalnızca değer 0&#39;dan büyük olduğunda gerçekleşmesi gerekir. Güncelleme sıklığındaki bu uyumsuzluk, bunun derivedStateOf için iyi bir kullanım durumu olduğu anlamına gelir.</p><p><strong>snapshotFlow</strong></p><p>snapshotFlow Jetpack Compose&#39;da bir State&lt;T&gt; nesnesini birFlow&#39;a dönüştürmek için kullanılan bir fonksiyondur. Bu, State nesnesinin değerlerindeki değişiklikleri takip etmek ve bu değişikliklere tepki vermek istediğimiz durumlarda kullanışlıdır.</p><pre>val listState = rememberLazyListState()<br><br>LazyColumn(state = listState) {<br>    // ...<br>}<br><br>LaunchedEffect(listState) {<br>    snapshotFlow { listState.firstVisibleItemIndex }<br>        .map { index -&gt; index &gt; 0 }<br>        .distinctUntilChanged()<br>        .filter { it == true }<br>        .collect {<br>            MyAnalyticsService.sendScrolledPastFirstItemEvent()<br>        }<br>}</pre><p>Verilen örnekte, snapshotFlow kullanarak bir listedeki ilk görünür öğenin indeksini takip eder ve kullanıcı bu öğeyi geçtiğinde bir analitik olayı gönderir:</p><ol><li><strong>listState Oluşturma:</strong> rememberLazyListState() ile bir listState oluşturulur.</li><li><strong>LazyColumn Oluşturma:</strong> listState kullanarak bir LazyColumn oluşturulur.</li><li><strong>snapshotFlow Kullanımı:</strong></li></ol><ul><li>LaunchedEffect ile listState&#39;e bağlı bir etki oluşturulur.</li><li>snapshotFlow ile listState.firstVisibleItemIndex bir Flow&#39;a dönüştürülür.</li><li>map operatörü ile indeks değeri 0&#39;dan büyükse true aksi takdirde false döndüren bir Flow oluşturulur.</li><li>distinctUntilChanged operatörü ile ardışık aynı değerlerin atlanması sağlanır.</li><li>filter operatörü ile sadece true değerlerini geçiren bir Flow oluşturulur.</li><li>collect operatörü ile Flow&#39;dan gelen değerlerde analitik olayı gönderilir.</li></ul><blockquote>snapshotFlow sadece State nesnelerini takip eder.</blockquote><blockquote>distinctUntilChanged benzeri davranışı sayesinde gereksiz yeniden hesaplamalar önlenir.</blockquote><blockquote>Flow operatörleri ile karmaşık durum yönetimi yapılabilir.</blockquote><p><strong>Restarting Effects</strong></p><p>Bazı effect’ler, belirli anahtar parametrelerin değişmesine bağlı olarak yeniden başlatılır. Aşağıdaki effect’ler, belirli koşullar altında yeniden başlatılır:</p><ul><li><strong>LaunchedEffect</strong>: Anahtar parametrelerden biri değişirse yeniden başlatılır.</li><li><strong>produceState</strong>: Parametreler değişirse yeniden başlatılır.</li><li><strong>DisposableEffect</strong>: Key parametrelerden biri değişirse yeniden başlatılır.</li><li><strong>SideEffect</strong>: Her başarılı compositiondan sonra çalışır, recomposition kavramı yoktur.</li><li><strong>rememberCoroutineScope</strong>: recomposition kavramı yoktur.</li></ul><blockquote>Call Site’nin yaşam döngüsünü takip etmesini sağlamak için effect key’i olarak true gibi bir sabit kullanabilirsiniz. Yukarıda gösterilen LaunchedEffect örneğinde olduğu gibi, bunun için geçerli kullanım durumları vardır.</blockquote><p><strong>SONUÇ</strong></p><p>Jetpack Compose, UI oluşturma sürecini basitleştirirken aynı zamanda esneklik ve kontrol sağlayan güçlü bir araçtır. Ancak, yan etkilerin yönetimi, uygulamanın kararlılığı ve performansı açısından kritik öneme sahiptir. Bu yazıda, Jetpack Compose’da yan etkileri nasıl yönetebileceğinizi, hangi senaryolarda hangi yan etki yöneticilerini kullanmanız gerektiğini ve doğru yaklaşımları inceledik.</p><p>Umarım bu yazı, Jetpack Compose projelerinizde yan etkileri daha etkili bir şekilde yönetmenize yardımcı olur. Yan etkilerin doğru yönetimi, uygulamalarınızın kullanıcı deneyimini iyileştirir ve geliştirici olarak size daha sürdürülebilir bir kod tabanı sunar.</p><p>Bu konuyla ilgili daha fazla bilgi ve detaylı rehberler için Jetpack Compose dokümantasyonunu inceleyebilir veya diğer yazılarımı okuyabilirsiniz. Herhangi bir sorunuz veya geri bildiriminiz varsa, yorumlar bölümünde benimle paylaşmaktan çekinmeyin:))</p><p>Okuduğunuz İçin Teşekkürler</p><p><strong>KAYNAKLAR</strong></p><p><a href="https://developer.android.com/develop/ui/compose/side-effects">https://developer.android.com/develop/ui/compose/side-effects</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b895bfd080f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 2 — Compose’da Lifecycle]]></title>
            <link>https://medium.com/@muratdayan359/part-2-composeda-lifecycle-0f57658ed81f?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f57658ed81f</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[lifecycle]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Mon, 08 Jul 2024 15:51:26 GMT</pubDate>
            <atom:updated>2024-07-08T16:06:45.862Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 2 — Compose’da Lifecycle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*98C7NFCE7xfp8BLUrUN2Nw.png" /><figcaption>Lifecycle In Compose</figcaption></figure><p>Merhabalar, serimizin 2.partıyla devam ediyoruz. Bu yazıda Compose’da lifecycle konusunu konuşacağız. Hazırsanız başlayalım.</p><p>Compose’da bileşenler composition işlemine tabi tutulur. Composition projemizin UI ağacıdır diyebiliriz. Projeyi ilk kez çalıştırdığınızda tüm bileşenler composition’a tabi tutulur ve ekranımızda çizilir.Ardından ise state’i değişen composable fonksiyonlar ekranda recomposition’a uğrayarak güncellenir. Composition’u değiştirmenin tek yolu recompositiondur. Bu yapıyı yukarıdaki resim ile daha güzel anlayabiliriz.</p><p>Bir composable fonksiyonunun yaşam döngüsü, bir bileşenin Composition’a eklenmesi, bir veya daha fazla kez yeniden çizilmesi (recomposition) ve son olarak Composition’dan çıkarılması ile tanımlanır.</p><p>Bu composition yapısı Activity veya fragmentlardaki lifecycle evrelerinden daha basit ve anlayışlıdır.</p><p>Bir composition’da her bileşen fonksiyondur bunu biliyoruz ve her bileşen çağrıldığında composition’da kendi yaşam döngüsü vardır.</p><pre>@Composable<br>fun MyComposable() {<br>    Column {<br>        Text(&quot;Hello&quot;)<br>        Text(&quot;World&quot;)<br>    }<br>}</pre><p>Yukarıdaki MyComposable fonksiyonu çağrıldığında, içindeki Column ve Text bileşenleri kendi yaşam döngülerini oluşturur. Her bir çağrı kendi instance&#39;ını oluşturur ve yönetir.</p><p><strong>Composition’da Composable Fonksiyonların Anatomisi</strong></p><p><strong>Call Site: </strong>Composition’da her bir Composable fonksiyonun örneği Call Site dediğimiz yapı tarafından tanımlanır.</p><p>Compose derleyicisi her Call Site’yi ayrı olarak değerlendirir. Birden çok Call Site tarafından çağrılan composable fonksiyonların her birinin birden çok örneği oluşturulur.</p><blockquote>Call Site bir composable fonksiyonun kaynak kodunun yerini belirler ve UI ağacını yani compositionu direkt olarak etkiler.</blockquote><p>Recomposition sırasında composable fonksiyonumuz ,farklı composable fonksiyonları çağırıyorsa, Compose hangi composable fonksiyonların çağrıldığını veya çağrılmadığını belirler ve önceki kompozisyonda çağrılan composable fonksiyonları atlar. Bu da recomposition’un önceki yazıda da söylediğimiz gibi iyimser olduğu özelliğidir.</p><pre>@Composable<br>fun LoginScreen(showError: Boolean) {<br>    if (showError) {<br>        LoginError()<br>    }<br>    LoginInput() <br>}<br><br>@Composable<br>fun LoginInput() { /* ... */ }<br><br>@Composable<br>fun LoginError() { /* ... */ }</pre><p>Yukarıdaki örnekte, LoginError sadece showError true olduğunda çağrılırken, LoginInput ilk compositionda kesin olarak çağrılır. Ardından, showError false olduğunda bile LoginInput yeniden çizilmez. Her çağrının kendine ait benzersiz bir call site’si vardır.</p><p><strong>Recomposition’u Akıllı Şekilde Ayarlamak</strong></p><p>Bir composable fonksiyon aynı çağrı yerinden birkaç defa çağrılırsa, Compose bu çağrıları benzersiz yapmak için yürütme sırasını kullanır bu da uygulamada istenmeyen sonuçlar doğurabilir.</p><pre>@Composable<br>fun MoviesScreen(movies: List&lt;Movie&gt;) {<br>    Column {<br>        for (movie in movies) {<br>            MovieOverview(movie)<br>        }</pre><p>Yukarıdaki kodda film listesi ilk olarak composition’a uğradıktan sonra, listenin sonuna yeni bir veri eklendiğinde yeni veri için instance’ı oluşturulur ve önceki veriler tutulabilir. Ama liste sırası değiştirilir, liste ortasına veya başına yeni veri gelirse ya da listenin kendisi değişirse tüm instance’lar tekrardan composition’a tabi tutulur.O yüzden bu kodda bir side-effect kodunuz varsa effect işlemi devam ederken recomposition olursa efekt iptal olup tekrardan çalıştırılacak.</p><p>Compose’da bu durumu çözmek için <em>key </em>kullanabiliriz. key keyword’u ile listedeki verilerin sırasını vs.. değiştirirsek composition’da önceki instance’ları kullanarak sırası değiştirilir ve tekrardan recomposition’a uğratmaz. Bir key değerinin global olarak benzersiz olması gerekmez, yalnızca çağrı alanındaki composable fonksiyonların çağrıları arasında benzersiz olması gerekir. Yani bu örnekte, her filmin filmler arasında benzersiz bir key’e sahip olması gerekir; bu key’in uygulamanın başka bir yerindeki başka bir composable ile paylaşması sorun değildir.</p><pre>@Composable<br>fun MoviesScreenWithKey(movies: List&lt;Movie&gt;) {<br>    Column {<br>        for (movie in movies) {<br>            key(movie.id) { // Unique ID for this movie<br>                MovieOverview(movie)<br>            }<br>        }<br>    }<br>}</pre><p>Yukarıdaki kodda liste elemanlarının yeri değişse bile compose MovieOverview’a yapılan çağrıları key üzerinden tanır ve tekrardan recomposition işlemine tabi tutmaz. Bu da uygulamamıza daha çok hız ve akıcılık sağlar performansı çoğaltır. Bu sayede side-effect kodlar varsa da çalışmaya devam eder ve uygulamamızda stabilite sağlar.</p><p>NOT: Bazı composable fonksiyonlar kendi içinde key değerine zaten sahiptirler. Örneğin LazyColumn fonksiyonunda aşağıdaki gibi kullanabiliriz.</p><pre>@Composable<br>fun MoviesScreenLazy(movies: List&lt;Movie&gt;) {<br>    LazyColumn {<br>        items(movies, key = { movie -&gt; movie.id }) { movie -&gt;<br>            MovieOverview(movie)<br>        }<br>    }<br>}</pre><p><strong>Recomposition Neleri Atlar?</strong></p><p>Recomposition sırasında bazı fonksiyonlar çizilmeden atlanır dedik. Aşağıdaki durumlar haricinde fonksiyon recompositiondan atlanabilir.</p><p>1- Composable Fonksiyonun dönüş tipi Unit değilse,</p><p>2-Fonksiyon @NonRestartableComposable veya @NonSkippableComposable anotasyonları ile işaretlenmişse,</p><p>3- Gerekli bir parametre stabil olmayan bir tipteyse</p><p>fonksiyonumuz recompositiona uğramak zorundadır.</p><p><strong>Bir Property’nin Stabil Olarak Kabul Edilmesi</strong></p><p>1- Aynı instance’ları equals ile karşılaştırıldığında sonucu her zaman aynı olmalıdır.</p><p>2- Türün bir özelliği değişirse, Örneğin mutableState türlerinde türün bir özelliği değişirse compose’a bildirim verilmelidir.</p><p>3- Tüm public property’ler stabildir.</p><blockquote>NOT: Tüm değişmez immutable tipler stable olarak kabul edilir.</blockquote><p><strong>Stabil Olarak Kabul Edilen Türler</strong></p><p>1- Primitive Tipler,</p><p>2- String,</p><p>3- Lambda fonksiyonları da stabil olarak kabul edilir çünkü fonksiyon referansları değişmez.</p><blockquote>NOT: Compose, MutableState türünü stabil olarak kabul eder. MutableState, içindeki değerin (value&#39;sinin) değiştiğinde Composition&#39;a bildirimde bulunur. Bu nedenle, MutableState türündeki bir değişkenin değeri değiştiğinde, Composition bu değişikliği fark eder ve gerekli yeniden kompozisyonları gerçekleştirir.</blockquote><p><strong>Stabil Olarak Kabul Edilmeyen Türler</strong></p><p>1- Interfaceler,</p><p>2- Eğer bir türün public özellikleri değişebilir ise, bu tür stabil olarak kabul edilmez çünkü bu özelliklerin değerleri değişebilir ve bu da Composition’a bildirilmelidir.</p><p><strong>@Stable Özelliği</strong></p><p>Eğer Compose bir türün stabil olup olmadığını belirleyemiyorsa, bu türü @Stable anotasyonu ile işaretleyerek Compose&#39;a stabil olduğunu belirtebilirsiniz.</p><pre>@Stable<br>interface UiState&lt;T : Result&lt;T&gt;&gt; {<br>    val value: T?<br>    val exception: Throwable?<br><br>    val hasError: Boolean<br>        get() = exception != null<br>}</pre><p>Yukarıdaki kod örneğinde, UiState interface&#39;i @Stable anotasyonu ile işaretlenmiştir. Bu, Compose&#39;a UiState interface’sinin stabil olduğunu belirtir ve bu interfacein kullanıldığı composable fonksiyonlarının recomposition sırasında daha akıllıca davranmasını sağlar. Bu sayede, UiState interfacesinin tüm uygulamaları da stabil olarak kabul edilir.</p><h3>Sonuç</h3><p>Bu bölümde Jetpack Compose’da lifecycle ve composition konularını ele aldık. Composable fonksiyonların nasıl yeniden çizildiğini ve performansı artırmak için nelere dikkat etmemiz gerektiğini öğrendik. Ayrıca, stabil türlerin önemini, @Stable anotasyonunun kullanımını ve <em>call site</em> kavramını keşfettik.</p><p>Bu bilgilerle, Jetpack Compose ile daha verimli ve performanslı uygulamalar geliştirebilirsiniz. Bir sonraki bölümde görüşmek üzere!</p><p>Mutlu kodlamalar! 😊</p><p><strong>KAYNAKLAR</strong></p><p><a href="https://developer.android.com/develop/ui/compose/lifecycle">https://developer.android.com/develop/ui/compose/lifecycle</a></p><ul><li><strong>String</strong>: String de stabil olarak kabul edilir çünkü immutable&#39;dır.</li><li><strong>Fonksiyon türleri (lambdalar)</strong>: Lambda fonksiyonları da stabil olarak kabul edilir çünkü fonksiyon referansları değişmez.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f57658ed81f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 1 — Compose Gibi Düşünmek]]></title>
            <link>https://medium.com/@muratdayan359/part-1-compose-gibi-d%C3%BC%C5%9F%C3%BCnmek-d37e16f4d675?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/d37e16f4d675</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[jetpack-compose-tutorial]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Sun, 07 Jul 2024 09:27:08 GMT</pubDate>
            <atom:updated>2024-07-07T09:27:08.411Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 1 — Compose Gibi Düşünmek</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bAAr0r0H24ny_NPxuHIeDw.png" /></figure><p>Merhabalar bu yazı serisinde <a href="https://developer.android.com/develop/ui/compose/documentation">https://developer.android.com/develop/ui/compose/documentation</a> sitesindeki dokümantasyona göre adım adım Compose yazılarını kendimce anlatmaya çalışacağım. İlk Adım olarak Thinking in Compose kısmından başlıyoruz.</p><p>Jetpack compose bildirimsel bir UI araç setidir. Declarative(bildirimsel) Api sağlayarak kullanıcı arayüzünü çizdirmemizi sağlar.</p><p><strong>Declarative Programlama’dan kasıt nedir?</strong></p><p>Biliyorsunuz ki XML’de bir Component tree katmanımız vardı ve burada bileşenlerimizi ekliyorduk. Ardından Activity veya Fragment’lardan findViewById veya binding işlemleri ile bileşenlere erişip state durumlarına göre bunları güncelliyorduk. Örneğin, img.setImageBitmap(Bitmap) gibi… Bu bileşenleri manuel değiştirmek, projemiz karmaşıklaştığında bize çok sıkıntı çıkarıyordu. Bileşenler uyumsuz bir şekilde değiştirilebiliyor veya bir yerde değişip diğer yerde değiştirilmesi unutuluyordu.</p><p>Fakat Declarative UI modelinde, belirli bir işlemin nasıl yapılacağını belirtmek yerine, ne yapılması gerektiğini ifade ederiz. Uygulamamız ilk çalıştığında tüm ekran sıfırdan çizilir ve sonra sadece gerekli bileşenler, yani state’i veya verisi değişen bileşenler, tekrardan çizilir. Bu şekilde bir ekran çizilmesine <em>Recomposition</em> diyoruz.</p><p><strong>Bir Composable Fonksiyon Nasıl Olmalı?</strong></p><pre>@Composable<br>fun Greeting (name: String){<br>  Text (&quot;Hello $name&quot;)<br>}</pre><p>1- Fonksiyon @Composable anotasyonu ile işaretlenmeli.</p><p>2- Composable fonksiyonlar parametre alabilir.</p><p>3- Composable fonksiyonlar kendi içerisinde başka bir composable fonksiyon çağırabilir. Örnekte Text() fonksiyonu da composable bir fonksiyondur zaten.</p><p>4- Composable fonksiyonların bir şey return etmesine gerek yoktur çünkü ekrana bileşen çizmek temel amacıdır.</p><p><strong>Declarative Değişimler?</strong></p><p>Imperative UI bileşenlerinde mesela Xml’de , her bileşenin kendi state’i vardır. Ve uygulamada bu state’lerle iletişime girmek için getter ve setter metotlarını kullanırız.</p><p>Declarative yaklaşımda ise getter ve setter metodları açığa çıkmaz. Bileşenler nesne gibi davranmaz, fonksiyon gibi davranırlar. Composable olan bu fonksiyonları farklı parametrelerle çağırarak yeni verilerle tekrardan çizilmesini sağlarız. Onclick gibi işlemlerle kullanıcı , arayüzle etkileşime girdiğinde uygulamaya bildirilir ve state veya veri değiştiğinde , composable fonksiyon tekrardan ekranda güncel verilerle çizilir. Buna Recomposition denir.</p><p><strong>Recomposition</strong></p><p>Imperative UI düzeninde setter metotlarıyla bileşeninin state’ini değiştiririz. Compose’da ise Composable fonksiyonu yeni datayla çağırırız ve Compose Frawework’u sadece değişen bileşeni yeni veriyle tekrardan çizer.</p><blockquote>Recomposition, yalnızca state veya veri değiştiğinde değil, Compose’un gereksinim duyduğu herhangi bir durumda gerçekleşebilir. Bu, yalnızca state değişiklikleriyle sınırlı değildir. Ayrıca, Compose’un mevcut durumu optimize etmek için tekrar tekrar çağırması da mümkündür.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hw5xByiZPqcvMiM4tm23iw.png" /><figcaption>recomposition</figcaption></figure><p>Aşağıdaki kodu inceleyelim:</p><pre>@Composable<br>fun ClickCounter(clicks: Int, onClick: () -&gt; Unit) {<br>    Button(onClick = onClick) {<br>        Text(&quot;bana $clicks kere tıkladın!&quot;)<br>    }<br>}</pre><p>Butona her tıklandığında clicks değeri değişiyorsa Compose, Text() fonksiyonunu yeniden çizdirir. Eğer tüm kullanıcı arayüzü her defasında değişseydi çok büyük performans isterdi ve bu performans cihazımızın batarya ömrünü azaltır , uygulamamızda farklı donma ve kasma sorunları ortaya çıkarabilirdi.</p><p>Bir fonksiyonun yeniden çizilmesi atlanabilir, yarıda kalabilir veya iptal olabilir. Bu yüzden bir composable fonksiyondaki side-effects olarak yazdığınız kodlara asla güvenmeyin mümkünse yazmayın, önerilmez.</p><p>Side-effects dediğimiz kodlar aşağıdaki gibi olabilir:</p><p>1-Global bir nesnenin verisinin değiştirilmesi</p><p>2- Viewmodel’de bir observable property’i güncelleme</p><p>3- Shared Preferences verisini güncelleme</p><p>vs gibi işlemlere side-effects denir.</p><p>Recomposition işlemi mümkün olan en hızlı şekilde gerçekleşmesi gereklidir. Bu yüzden ağır işlemleri composable fonksiyonlarda yapmayınız. Viewmodelde veya herhangi bir class’ta Coroutine kullanarak arka planda yapıp sonucunu composable fonksiyona vermelisiniz.</p><pre>@Composable<br>fun SharedPrefsToggle(<br>    text: String,<br>    value: Boolean,<br>    onValueChanged: (Boolean) -&gt; Unit<br>) {<br>    Row {<br>        Text(text)<br>        Checkbox(checked = value, onCheckedChange = onValueChanged)<br>    }<br>}</pre><p>Örneğin yukarıdaki kod’a shared’den aldığımız verileri veya butona tıklanınca shared’ten veriyi almayı yaptırtabiliriz. Sadece sonuçları döndürüyoruz. Temiz olan bu şekildedir.</p><p><strong>Composable Kullanırken Dikkat Edin</strong></p><p>1- Composable fonksiyonlar sırayla değil, karışık şekilde çağrılır.</p><p>2- Composable fonksiyonlar paralel çağrılabilir.</p><p>3- Recomposition mümkün olduğunca composable fonksiyonunuzu veya lambdanızı atlamak ister.</p><p>4- Recomposition iptal olabilir, iyimser davranır.</p><p>5- Composable fonksiyon bir animasyonun her karesi gibi sıklıkla çalıştırılabilir.</p><p><strong>Composable Fonksiyon Sırasız Çağrılabilir</strong></p><pre>@Composable<br>fun ButtonRow() {<br>    MyFancyNavigation {<br>        StartScreen()<br>        MiddleScreen()<br>        EndScreen()<br>    }<br>}</pre><p>Compose, bazı fonksiyonları bazılarından önce ekrana çizebilir. Yani yukarıdaki örnekteki StartScreen(), MiddleScreen(), EndScreen() fonksiyonları herhangi bir sırada çağrılabilir. Bu da demek oluyor ki StartScreen’deki bir veriye göre MiddleScreen() çizilimi uygulamanızda saçma ve absürt durumlar ortaya çıkarabilir. Bu nedenle her bir Composable fonksiyon kendi kendine yetmelidir başka bir fonksiyona mümkün olduğunca bağımlı olmamalıdır.</p><p><strong>Composable Fonksiyon Paralel Çalıştırılabilir</strong></p><p>Compose, birden fazla fonksiyonu paralel çağırarak birden fazla çekirdek kullanabilir. Yani arka planda bir thread havuzu vardır. Yani bir fonksiyon birkaç farklı yerden çağrılabilir. Bu yüzden side-effects kullanımları fonksiyonlar içinde önerilmez.</p><pre>@Composable<br>@Deprecated(&quot;Example with bug&quot;)<br>fun ListWithBug(myList: List&lt;String&gt;) {<br>    var items = 0<br><br>    Row(horizontalArrangement = Arrangement.SpaceBetween) {<br>        Column {<br>            for (item in myList) {<br>                Text(&quot;Item: $item&quot;)<br>                items++ // side-effect kod<br>            }<br>        }<br>        Text(&quot;Count: $items&quot;)<br>    }<br>}</pre><p>Önreğin yukarıdaki kodda <em>items</em> property’si her recomposition işleminde yeniden değiştirilir. Bu fazlaca değişim kullanıcı arayüzünde yanlış sayıyı gösterecektir. Bu yüzden bu şekil yazmalardan kaçınmak gerekir.</p><p><strong>Recomposition Mümkün Olduğunca Geçiştirilir</strong></p><p>Compose , arayüzde yalnızca güncellenmesi gerekilen yeri tekrar çizer. Her composable fonksiyon ve lambda kendi başına tekrar oluşabilir. Yani kendi verisi değiştiğinde güncellenir. Aşağıdaki kodda bunu inceleyebilirsiniz.</p><pre>/**<br> * Kullanıcıya bir başlık yazısı ve bir liste gösteren kod<br> */<br>@Composable<br>fun NamePicker(<br>    header: String,<br>    names: List&lt;String&gt;,<br>    onNameClicked: (String) -&gt; Unit<br>) {<br>    Column {<br>        // Bu Text fonksiyonu yalnızca header parametresi değiştiğinde tekrar çizilir<br>        Text(header, style = MaterialTheme.typography.bodyLarge)<br>        Divider()<br><br>        // LazyColumn, Recycler View&#39;in benzeri diyebiliriz<br>        LazyColumn {<br>            items(names) { name -&gt;<br>                // itemlerin name&#39;leri değiştiğinde burası tekrar çizilir.<br>                // header değiştiğinde burası tekrar çizilmez<br>                NamePickerItem(name, onNameClicked)<br>            }<br>        }<br>    }<br>}<br><br>/**<br> * kullanıcı tıkladığında ismi arayüzde gösteren kod<br> */<br>@Composable<br>private fun NamePickerItem(name: String, onClicked: (String) -&gt; Unit) {<br>    Text(name, Modifier.clickable(onClick = { onClicked(name) }))<br>}</pre><p><strong>Recomposition İyimserdir</strong></p><p>Recomposition yapılırken işlem daha bitirilmeden bir parametre değişirse, Compose, bu recomposition’u iptal edebilir ve yeni parametreyle yeniden başlatır. Recomposition iptal olursa compose bu UI ağacını atar ama eğer bu fonksiyonda bir side-effect olan kod satırı varsa , bu kod çalışacaktır ve bu da uygulamanızda tutarsızlıklara yol açabilir.</p><p><strong>Sonuç</strong></p><p>Bu partta Jetpack Compose’u ve bildirimsel UI yaklaşımını keşfettik. Declarative Programlama’nın, özellikle karmaşık projelerde, UI bileşenlerinin yönetimini nasıl kolaylaştırdığını gördük. Composable fonksiyonların nasıl çalıştığını, yeniden çizim (recomposition) süreçlerini ve Side-effect’lerin nasıl yönetilmesi gerektiğini öğrendik. Compose’un performans odaklı tasarımı ve UI bileşenlerini en verimli şekilde güncelleme stratejileri, modern Android uygulamaları geliştirme sürecini büyük ölçüde iyileştiriyor. Bu temel bilgilerle, Jetpack Compose ile daha etkin ve sürdürülebilir uygulamalar geliştirebilirsiniz.</p><p><strong>Kaynaklar</strong></p><p><a href="https://developer.android.com/develop/ui/compose/mental-model">https://developer.android.com/develop/ui/compose/mental-model</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d37e16f4d675" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Activity Launch Modes]]></title>
            <link>https://medium.com/@muratdayan359/android-activity-launch-modes-b2f59c742f96?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2f59c742f96</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[manifest-launch-mode]]></category>
            <category><![CDATA[activity]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Mon, 01 Jul 2024 14:21:37 GMT</pubDate>
            <atom:updated>2024-07-01T14:21:37.122Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BfTylCwe2UDFtJ4AWA8i_w.jpeg" /><figcaption>Launch Modes and Tasks</figcaption></figure><p>Merhabalar 👋</p><p>Android uygulamalarını geliştirirken bazen aktivitelerin nasıl başlatıldığını ve bu durumun uygulamanızın davranışını nasıl etkilediğini anlamak zor olabilir.Bu yazımda, Android aktiviteleri için farklı launch mode’ları keşfedeceğiz ve bu modların uygulamamızda nasıl çalıştığını öğreneceğiz. Eğer kafanızda “Launch mode ne demek?” gibi sorular varsa ya da mevcut bilginizi tazelemek istiyorsanız, doğru yerdesiniz!</p><p>Ancak konuya dalmadan önce, aktivitelerin nasıl çalıştığını ve kullanıcı deneyimini nasıl şekillendirdiğini anlamak için iki önemli kavramı ele alalım: Task ve Backstack.</p><p><strong>Task</strong>: Bir Task, kullanıcı bir uygulamayı başlattığında oluşturulan aktiviteler kümesidir. Bir Task, genellikle uygulamanın ana ekranından başlar ve kullanıcı uygulamada gezinirken yeni aktiviteler eklenir. Örneğin, bir mesajlaşma uygulamasında, ana ekran bir Task oluşturur ve kullanıcı mesajları okurken veya yeni bir mesaj yazarken bu Task’e yeni aktiviteler eklenir.</p><p><strong>Backstack</strong>: Backstack, bir Task içindeki aktivitelerin sıralı bir listesidir. Kullanıcı geri tuşuna bastığında, Backstack’teki son aktivite kapatılır ve bir önceki aktiviteye geri dönülür. Bu mekanizma, kullanıcıların doğal bir şekilde uygulama içinde gezinmelerini sağlar. Backstack, uygulamanın nasıl davrandığını ve kullanıcıların hangi ekranlara nasıl döneceğini belirlemede önemli bir rol oynar.</p><p>Bu temel kavramları anladıktan sonra, launch mode’ların bu yapılar üzerinde nasıl etkili olduğunu ve uygulamanızın davranışını nasıl şekillendirdiğini inceleyeceğiz.</p><blockquote>NOT: Android Studio’da bu backstack’i izlemek için Android Studio&gt;Settings&gt;Languages&amp;Frameworks&gt;AndroidSDK dosyasına gidin</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6iBgM88h9oXh3xUr0qlViQ.png" /><figcaption>SDK</figcaption></figure><blockquote>Android SDK Location kısmında yolunuzu alın ve terminalde o yola gidip ardından <strong><em>adb shell dumpsys activity activities | findstr “Hist”</em>| Select-String -Pattern “ActivityRecord”</strong> bu kodu yazdığımızda backstack ve task bilgilerine ulaşacağız. Yazının devamında bu işleme göre sonuçlar yazılmıştır.</blockquote><blockquote>NOT 2: Launch mode bilgisi AndroidManifest.xml dosyasında activity tagleri arasına yazılır.</blockquote><pre>&lt;activity<br>    android:name=&quot;.standard.SecondActivity&quot;<br>    android:exported=&quot;false&quot;<br>    android:launchMode=&quot;standard&quot;<br>    /&gt;</pre><p>Hadi gelin, bu önemli konuyu birlikte keşfedelim ve uygulamalarımızı daha kullanıcı dostu hale getirelim. 🚀</p><p>Öncelikle</p><p>Bu yazıda 5 farklı mod yapısından bahsedeceğiz.</p><p><strong>1- Standard</strong></p><p>Bu mod, Android aktiviteleri için varsayılan başlatma modudur. Default olarak bu mod zaten vardır ama yine de eklemek isterseniz manifest dosyasına aşağıdaki satırı ekleyebilirsiniz.</p><pre>&lt;activity android:launchMode=&quot;standard&quot;&gt;</pre><p>Her seferinde bir aktivite başlatıldığında, yeni bir örneği oluşturulur ve mevcut Task’ın üstüne eklenir. Başka bir deyişle, aynı aktiviteyi birden fazla kez başlattığınızda, her biri Backstack’te ayrı bir giriş olarak yer alır.</p><p>Örneğin 2 farklı activity arasında intent ile gidip gelindiğinde backstack durumumuz aşağıdaki gibi olacaktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K3RUAc_Ajn90Dyn2ZUzSTA.png" /><figcaption>First&gt;Second&gt;First&gt;Second&gt;First</figcaption></figure><p>Burdan da görüldüğü üzere tüm Activityler aynı task üzerinde fakat her intent ile geçişte Activity’nin yeni bir instance’ı oluşturuluyor. Geri butonuna basınca önceki instance’lara ulaşıp en alt Activity’e geldikten sonra tekrar geriye basılınca uygulama arka plana alınacaktır.</p><p><strong>2-SingleTop Mode</strong></p><p>Bu mod, bir aktivite başlatıldığında, eğer aktivite zaten backstack’in en üstünde varsa, yeni bir örneği oluşturmak yerine varolan aktiviteyi kullanır. Ancak, eğer aktivite backstack’in en üstünde değilse, yeni bir örneği oluşturarak backstack’e ekler.</p><blockquote>NOT: SingleTop Activity olan Activity’miz backstack’te en üstte olmalıdır en üstte değilse kendini onCreate yaparak açar ve standard mod gibi davranır.</blockquote><p>SecondSingleTopActivity’mizin launch modunu singleTop yapalım.</p><pre>&lt;activity<br>    android:name=&quot;.singletop.SecondSingleTopActivity&quot;<br>    android:exported=&quot;false&quot;<br>    android:launchMode=&quot;singleTop&quot;<br>    /&gt;</pre><p>First Activity’den Second’a geçtik.Second’da Tekrar kendisini intent edersek SecondSingleTopActivity’nin onCreate’i çalışmaz. OnNewIntent fonksiyonu çalışır. Aynı task içinde olurlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RX4CNw_Lu_tF3jzZ6ECAvw.png" /><figcaption>First&gt;Second&gt;Second</figcaption></figure><p>Asağıda SecondSingleTopActivity kodları verilmiştir ve onNewIntent sonucu gösterilmiştir.</p><pre>class SecondSingleTopActivity : AppCompatActivity() {<br>    private lateinit var binding: ActivitySecondSingleTopBinding<br><br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br>        binding = ActivitySecondSingleTopBinding.inflate(layoutInflater)<br>        setContentView(binding.root)<br><br>        binding.btnOpenFirstSingleTopActivity.setOnClickListener {<br>            startActivity(Intent(this, FirstSingleTopActivity::class.java))<br>        }<br><br>        binding.btnOpenSecondSingleTopActivity.setOnClickListener {<br>            startActivity(Intent(this, SecondSingleTopActivity::class.java))<br>        }<br>    }<br><br>    override fun onNewIntent(intent: Intent) {<br>        super.onNewIntent(intent)<br>        Toast.makeText(this, &quot;onNewIntent&quot;, Toast.LENGTH_SHORT).show()<br>    }<br><br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xh36WXVMBY6qV6dnFP73DQ.png" /><figcaption>OpenYoursel butonuna tıklanınca kendini oncreate etmez onnewIntent eder.</figcaption></figure><p><strong>3- Single Task</strong></p><p>Bu mod, bir aktivite başlatıldığında, kendisiyle aynı Task içinde yalnızca bir tane örneğinin olmasını sağlar. Yani, eğer ilgili Task’te zaten bir örneği varsa, bu örnek kullanılır ve onNewIntent fonksiyonu çağr. Eğer Task içinde daha önce bu aktiviteden örnek yoksa, yeni bir örnek oluşturulur.</p><p>3 Activity oluşturduk ve SecondSingleTaskActivity’nin modunu singleTask yapalım.</p><pre>&lt;activity<br>    android:name=&quot;.singletask.SecondSingleTaskActivity&quot;<br>    android:exported=&quot;false&quot;<br>    android:launchMode=&quot;singleTask&quot;<br>    /&gt;</pre><p>First&gt;Second&gt;Third&gt;Second akışını sağlarsak aşağıdaki gibi bir backstack durumu görünür.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*03CJiBLYTVFsOeW1hzQOuw.png" /><figcaption>First&gt;Second&gt;Third</figcaption></figure><p>yukarıdaki şekilde görüldüğü gibi FirstActivity’den SecondSingleTaskActivity’e geçtik , Sonra ThirdActivity’e geçtik daha sonra tekrar Second’a geçersek Second task içinde backstack’de zaten olduğu için o backstack’e geçilir ve onun üzerinde kalan Third Activity’nin backstack’i silinir.Bu şekilde tek bir Task içinde bir sadece bir örnek oluşturulmasını sağlar.Second’a ilk gittikten sonra kaç defa gelinirse gelinsin onCreate çağrılmaz, onNewIntent çağrılır ve Second’tan sonra oluşturulan backstack instance’ları silinir. Aşağıda görüldüğü üzere Third’den gelinmesine rağmen ThirdActivity backstackden silinmiş olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ngsXiImEGn4otImMPVMAA.png" /><figcaption>First&gt;Second&gt;Third&gt;Second</figcaption></figure><p><strong>4-Single Instance</strong></p><p>Bu mod, bir aktivite başlatıldığında, kendisi için ayrılmış özel bir Task’te tek bir örnek olmasını sağlar. Yani, bu aktivitenin yalnızca bir tane örneği olabilir ve bu örnek, farklı Task’lerde veya diğer uygulamalarla paylaşılmaz.</p><p>3 Activity oluşturduk.First&gt;Second&gt;Third diye akışımız olsun.SecondSingleInstanceActivity’i singleInstance yapalım.</p><pre>&lt;activity<br>    android:name=&quot;.singleinstancce.SecondSingleInstanceActivity&quot;<br>    android:exported=&quot;false&quot;<br>    android:launchMode=&quot;singleInstance&quot;<br>    /&gt;</pre><p>First’ten Second’a geçersek;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sPXADlIlZlTymJoBvH4lrw.png" /><figcaption>First&gt;Second</figcaption></figure><p>Yukarıda da görüldüğü gibi SecondActivity’miz t2328 gibi farklı bir Task’de açılmıştır.</p><p>First&gt;Second&gt;Third geçersek;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ShCL__p3jSNhERzZbF5TOw.png" /><figcaption>First&gt;Second&gt;Third</figcaption></figure><p>Burda ise Second’dan Third’e geçilince Third Activity’nin backstacki First Activity’nin bulunduğu Task’e eklenmiş olup Third’den geri tuşuna basarsak, Second’a uğramadan First’e geçmiş olacağız.</p><p>Sonuç olarak single Instance modu yeni bir task’da açılır. Eğer o task’de örnek varsa onCreate çalışmaz, onNewIntent çalışır.</p><p><strong>5- Single Instance Per Task</strong></p><p>Android API seviyesi 30 (Android 11) ile tanıtılmıştır. Bu mod, aktivitenin her bir Task için ayrı bir örneğinin olmasını sağlar. Yani, her Task içinde bu aktivitenin yalnızca bir tane örneği olabilir ve bu örnek, o Task içinde tekrar tekrar başlatılsa bile aynı örneği kullanır.</p><p>3 activity oluşturduk ve Second Activity’i singleInstancePerTask yaptık.</p><pre>&lt;activity<br>    android:name=&quot;.singleinstancepertask.SecondSingleInstancePerTaskActivity&quot;<br>    android:exported=&quot;false&quot;<br>    android:launchMode=&quot;singleInstancePerTask&quot;/&gt;</pre><p>First&gt;Second geçersek;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MzN01N8NfWDwlwEZY-65bg.png" /><figcaption>First&gt;Second</figcaption></figure><p>yukarıda görüldüğü üzere single Instance gibi SecondActivity’miz yeni bir Task içinde açılıyor.</p><p>First&gt;Second&gt;Third geçersek;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uk0AGnOteGH9gx6_AOYITQ.png" /><figcaption>First&gt;Second&gt;Third</figcaption></figure><p>Burda görüldüğü üzere Third Activity Second Activity’nin bağlı olduğu task içinde açıldı ve Third Activity’den geri tuşuna basarsak Second Activity açılacaktır.</p><p>Bu şekilde SingleInstancePerTask modunda olan bir Activity’den başka Activity’lere geçiş yapıldığında Second Activity’nin kendi taskını paylaşır.</p><p><strong>Sonuç</strong></p><p>Android launch modları, uygulamanızın kullanıcı deneyimini ve aktiviteler arasındaki geçişleri yönetmek için güçlü bir araç seti sunar. Uygulamanızın gereksinimlerine ve kullanıcı etkileşimlerine bağlı olarak doğru launch modunu seçmek, performansı artırabilir ve tutarlı bir kullanıcı deneyimi sağlayabilir.</p><p>Başlatma modlarıyla ilgili seçiminiz, uygulamanızın mimarisini ve kullanıcı beklentilerini dikkate almalıdır. Her bir launch modunun sunduğu avantajları ve kullanım senaryolarını anlamak, Android uygulama geliştirmede başarı için önemli bir adımdır.</p><p>Okuduğunuz için Teşekkürler:)</p><p>Geri dönüş , eleştiri veya bilgi eklemeleriniz varsa yazabilirsiniz:)</p><p>Bir dahaki yazıda görüşmek üzere…</p><p><strong>Kaynaklar</strong></p><p><a href="https://www.youtube.com/watch?v=xrFHNaXOMDY">https://www.youtube.com/watch?v=xrFHNaXOMDY</a></p><p>Kodlar-&gt; <a href="https://github.com/murat-dayan/ActivityLaunchModes/tree/master">https://github.com/murat-dayan/ActivityLaunchModes/tree/master</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2f59c742f96" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Onboarding Screens With Jetpack Compose]]></title>
            <link>https://medium.com/@muratdayan359/onboarding-screens-with-jetpack-composed-ac00c806752e?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac00c806752e</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[onboarding]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Fri, 14 Jun 2024 15:41:29 GMT</pubDate>
            <atom:updated>2024-07-08T07:47:55.434Z</atom:updated>
            <content:encoded><![CDATA[<p>Merhabalar , bu yazımda Splash Screen api kullanarak bir Splash screen ve ardından ise Onboarding screen tasarımları yapcaz. Onboarding sayfaları, kullanıcıların bir uygulamayı ilk kez açtıklarında karşılaştıkları rehberlik ve bilgilendirme ekranlarıdır. Bu sayfalar, kullanıcılara uygulamanın temel özelliklerini tanıtmak, kullanıcı deneyimini artırmak ve kullanıcıların uygulamayı daha verimli bir şekilde kullanmalarına yardımcı olmak amacıyla tasarlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*af7T_m_vl4-DB3zzwHIyHg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GPZes_UF_9C687tDq1gCoQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kenRbK8DoW75OSqQEqYT-A.png" /><figcaption>OnBoarding Pages</figcaption></figure><p>Şimdi adım adım yukarıdaki tasarımı yapacağız. Let’s Goo:)</p><p><strong>1- Splash Screen Dependency Implementation</strong></p><p>Aşağıdaki kodu Build.Gradle(module) dosyamıza ekleyip sync now yapalım.</p><pre>implementation(&quot;androidx.core:core-splashscreen:1.0.0&quot;)</pre><p><strong>2- Splash Screen Style</strong></p><p>Values klasörü altındaki Themes.xml dosyasına aşağıdaki gibi bir style tanımlayalım. Bu sayede splash screen logosu, arka plan rengi, görünüm süresi ve temamızı belirliyoruz.</p><pre>&lt;style name=&quot;SplashTheme&quot; parent=&quot;Theme.SplashScreen&quot;&gt;<br>        &lt;item name=&quot;windowSplashScreenBackground&quot;&gt;@color/white&lt;/item&gt;<br>        &lt;item name=&quot;windowSplashScreenAnimatedIcon&quot;&gt;@drawable/ic_love&lt;/item&gt;<br>        &lt;item name=&quot;windowSplashScreenAnimationDuration&quot;&gt;1000&lt;/item&gt;<br>        &lt;item name=&quot;postSplashScreenTheme&quot;&gt;@style/Theme.OnBoardingScreen&lt;/item&gt;<br>&lt;/style</pre><p><strong>a- Change Theme In The Manifest</strong></p><p>Manifest.xml dosyasındaki android:theme satırına kendi style dosyamızı verelim.</p><pre>android:theme=&quot;@style/SplashTheme&quot;&gt;</pre><p><strong>b- Install Splash Screen</strong></p><p>Aşağıdaki kodu MainActivity onCreate fonksiyonunda en üste yazalım.installSplashScreen(), uygulamanın başlatılması sırasında açılış ekranının otomatik olarak gösterilmesini ve yönetilmesini sağlar. Bu fonksiyon genellikle bir aktivitenin onCreate() metodunda çağrılır ve Splash Screen API&#39;sinin açılış ekranını kurmasını sağlar.</p><pre>installSplashScreen()</pre><p><strong>3-Sealed Classes For Onboarding Pages</strong></p><p>Burda onboarding sayfalarımızı temsil edecek bir sealed class tanımlıyoruz.Bu sayfa geçişlerinde işimizi kolaylaştıracaktır. Her bir sayfa title, description ve image bilgisi tutuyor. Kendi tasarımlarınıza göre bu bilgileri değiştirebilirsiniz.</p><pre>sealed class OnBoardingModel(<br>    @DrawableRes val image:Int,<br>    val title:String,<br>    val description:String<br>){<br>    data object FirstPages : OnBoardingModel(<br>        image = R.drawable.img1,<br>        title = &quot;First Page&quot;,<br>        description = &quot;This is the first page description&quot;<br>    )<br><br>    data object SecondPages : OnBoardingModel(<br>        image = R.drawable.img2,<br>        title = &quot;Second Page&quot;,<br>        description = &quot;This is the second page description&quot;<br>    )<br><br>    data object ThirdPages : OnBoardingModel(<br>        image = R.drawable.img3,<br>        title = &quot;Third Page&quot;,<br>        description = &quot;This is the third page description&quot;<br>    )<br>}</pre><p><strong>4- Top Section UI</strong></p><p>Onboarding sayfalarımızın üst kısmını ve alt kısmını ayrı ayrı tasarlayacağız. Aşağıdaki kodda title , resim ve description bir column içinde alt alta tasarımı yapılmıştır. Bu fonksiyona gelen onboardingModel nesnesiyle bilgileri yazdırmış oluyoruz.</p><pre>@Composable<br>fun OnBoardingGraphUi(onBoardingModel: OnBoardingModel) {<br><br>    Column(<br>        modifier = Modifier.fillMaxWidth()<br>    ) {<br>        Spacer(modifier = Modifier.size(50.dp))<br><br>        Image(<br>            painter = painterResource(id = onBoardingModel.image),<br>            contentDescription = null,<br>            modifier = Modifier<br>                .fillMaxWidth()<br>                .padding(50.dp, 0.dp),<br>            alignment = Alignment.Center<br>        )<br><br>        Spacer(modifier = Modifier.size(50.dp))<br><br>        Text(<br>            text = onBoardingModel.title,<br>            modifier = Modifier.fillMaxWidth(),<br>            fontSize = 20.sp,<br>            textAlign = TextAlign.Center,<br>            style = MaterialTheme.typography.titleMedium,<br>            color = MaterialTheme.colorScheme.onBackground<br>        )<br><br>        Spacer(modifier = Modifier.size(10.dp))<br><br>        Text(<br>            text = onBoardingModel.description,<br>            modifier = Modifier<br>                .fillMaxWidth()<br>                .padding(15.dp, 0.dp),<br>            fontSize = 16.sp,<br>            textAlign = TextAlign.Center,<br>            style = MaterialTheme.typography.bodySmall,<br>            color = MaterialTheme.colorScheme.onSurface<br>        )<br>        Spacer(modifier = Modifier.size(10.dp))<br>    }<br>}</pre><p><strong>5- Indicator UI</strong></p><p>Tasarımımızda 3 nokta tutcaz ve geçişleri daha görsel hala getirmek için bu noktaları kullanıcıya göstereceğiz. Bu yapıya indicator deniliyor. Her bir nokta tasarımı bir onboarding sayfamızı temsil edecektir ve mevcut sayfa hangisiyse o noktanın arka plan rengi ve boyutu değişiyor.</p><pre>@Composable<br>fun IndicatorUi(<br>    pageSize:Int,<br>    currentPage:Int,<br>    selectedColor: Color = MaterialTheme.colorScheme.secondary,<br>    unSelectedColor: Color = MaterialTheme.colorScheme.secondaryContainer<br>){<br><br>    Row (<br>        horizontalArrangement = Arrangement.SpaceBetween<br>    ){<br>        repeat(pageSize){<br>            Spacer(modifier = Modifier.size(2.5.dp))<br>            Box(<br>                modifier = Modifier<br>                    .height(14.dp)<br>                    .width(width = if (it == currentPage) 32.dp else 16.dp)<br>                    .clip(RoundedCornerShape(10.dp))<br>                    .background(color = if (it == currentPage) selectedColor else unSelectedColor)<br>            ){<br><br>            }<br>        }<br>    }<br>}</pre><p><strong>6- Button UI</strong></p><p>Tasarımımızın alt kısmında iki buton olcak bu butonların tasarımı fonksiyonda aldığımız parametrelere göre değiştirilebilir haldedir.</p><pre>@Composable<br>fun ButtonUi(<br>    text: String = &quot;Next&quot;,<br>    backgroundColor: Color = MaterialTheme.colorScheme.primary,<br>    textColor: Color = MaterialTheme.colorScheme.onPrimary,<br>    textStyle: TextStyle = MaterialTheme.typography.titleMedium,<br>    fontSize: Int = 14,<br>    onClick: () -&gt; Unit<br>) {<br><br>    Button(<br>        onClick = onClick,<br>        colors = ButtonDefaults.buttonColors(<br>            containerColor = backgroundColor,<br>            contentColor = textColor<br>        ),<br>        shape = RoundedCornerShape(10.dp),<br>    ) {<br><br>        Text(text = text, fontSize = fontSize.sp, style = textStyle)<br>    }<br>}</pre><p><strong>7- OnBoardingScreen</strong></p><p>Ve asıl onboarding sayfamıza geldik. Bu sayfada OnBoardingModel class’ını tutan ve 3 sayfa olduğuiçin 3 elemanlı bir pages listesi belirledik. HorizontalPager’da kullanmak üzere pagerState nesnemizi tanımladık. Ve ilk sayfa ve son sayfaya göre butonlarımızın tasarımını ve text’ini değiştirebilmek için buttonState belirledik. Scaffold’un Bottom Bar’ında IndicatorUI ve ButtonUI tasarımlarını kullandık. Button’un onclick parametresine kullanıcının tıklama işlemini gerçekleştirince horizontalpager’in diğer sayfaya geçişini sağladık. Ayrıca yana kaydırınca da bu işlem olacaktır.</p><blockquote>Horizontal pager’in animateToScrollPage fonksiyonu asenkron bir işlem olacağından scope adında bir rememberCoroutineScope nesnesi ile scope.launch{} bloğu kapsamında bu fonksiyonu yapmamız gereklidir.</blockquote><p>pagerState bizim mevcut sayfamızı tuttuğu için bu değişkeni kontrol ederek sayfamızı back butonunda geriye( -1 yaparak) , next butonunda ileriye(+1 yaparak) doğru kaydırdık.</p><p>Content içinde ise HorizontalPager kapsamında onboardingGraphUi fonksiyonumuzu verdik ve Scaffold’un content kısmında görünmesini sağladık.</p><pre>@OptIn(ExperimentalFoundationApi::class)<br>@Composable<br>fun OnBoardingScreen(<br>    onFinished: () -&gt; Unit<br>) {<br><br>    val pages =<br>        listOf(OnBoardingModel.FirstPages, OnBoardingModel.SecondPages, OnBoardingModel.ThirdPages)<br><br>    val pagerState = rememberPagerState(initialPage = 0) {<br>        pages.size<br>    }<br><br>    val buttonState = remember {<br>        derivedStateOf {<br>            when (pagerState.currentPage) {<br>                0 -&gt; listOf(&quot;&quot;, &quot;Next&quot;)<br>                1 -&gt; listOf(&quot;Back&quot;, &quot;Next&quot;)<br>                2 -&gt; listOf(&quot;Back&quot;, &quot;Done&quot;)<br>                else -&gt; listOf(&quot;&quot;, &quot;&quot;)<br>            }<br>        }<br>    }<br><br>    val scope = rememberCoroutineScope()<br><br>    Scaffold(<br>        bottomBar = {<br>            Row(<br>                modifier = Modifier<br>                    .fillMaxWidth()<br>                    .padding(10.dp, 10.dp),<br>                horizontalArrangement = Arrangement.SpaceBetween,<br>                verticalAlignment = Alignment.CenterVertically<br>            ) {<br>                Box(<br>                    modifier = Modifier.weight(1f),<br>                    contentAlignment = Alignment.CenterStart<br>                ) {<br>                    if (buttonState.value[0].isNotEmpty()) {<br>                        ButtonUi(<br>                            text = buttonState.value[0],<br>                            backgroundColor = Color.Transparent,<br>                            textColor = Color.Gray,<br>                            onClick = {<br>                                scope.launch {<br>                                    if (pagerState.currentPage &gt; 0) {<br>                                        pagerState.animateScrollToPage(pagerState.currentPage - 1)<br>                                    }<br>                                }<br>                            }<br>                        )<br>                    }<br>                }<br><br>                Box(<br>                    modifier = Modifier.weight(1f),<br>                    contentAlignment = Alignment.Center<br>                ) {<br>                    IndicatorUi(pageSize = pages.size, currentPage = pagerState.currentPage)<br><br>                }<br><br>                Box(<br>                    modifier = Modifier.weight(1f),<br>                    contentAlignment = Alignment.CenterEnd,<br>                ) {<br>                    ButtonUi(<br>                        text = buttonState.value[1],<br>                        backgroundColor = MaterialTheme.colorScheme.primary,<br>                        textColor = MaterialTheme.colorScheme.onPrimary,<br>                        onClick = {<br>                            scope.launch {<br>                                if (pagerState.currentPage &lt; pages.size -1){<br>                                    pagerState.animateScrollToPage(pagerState.currentPage +1)<br>                                }else{<br>                                    onFinished()<br>                                }<br>                            }<br>                        }<br>                    )<br>                }<br>            }<br>        },<br>        content = {<br>            Column(<br>                modifier = Modifier.padding(it)<br>            ) {<br>                HorizontalPager(state = pagerState) { index -&gt;<br>                    OnBoardingGraphUi(onBoardingModel = pages[index])<br>                }<br>            }<br>        }<br>    )<br>}</pre><p><strong>8-Shared Preferences for OnBoarding Page Visibility</strong></p><p>Aşağıda Shared Preferences kullanarak , kullanıcıya Onboarding sayfalarımızı sadece ilk kullanışta görünmesinin kontrolünü sağlıyoruz.</p><pre>class OnBoardingUtils(private val context: Context){<br><br>    fun isOnBoardingComplete():Boolean{<br>        return context.getSharedPreferences(&quot;onboarding&quot;,Context.MODE_PRIVATE)<br>            .getBoolean(&quot;completed&quot;,false)<br>    }<br><br>    fun setOnBoardingComplete(){<br>        context.getSharedPreferences(&quot;onboarding&quot;,Context.MODE_PRIVATE)<br>            .edit()<br>            .putBoolean(&quot;completed&quot;,true)<br>            .apply()<br>    }<br>}</pre><p><strong>9-MainActivity</strong></p><p>Shared fonksiyonlarını kullanabilmek için onboardingUtils nesnesini oluşturduk. Main içinde Shared içindeki isOnBoardingComplete fonksiyonundan dönen boolean değerine göre true ise HomeScreen’e kullanıcı gidiyoreğer false ise kullanıcı ilk defa gelmiştir ve Onboarding sayfalarımızı gösteriyoruz.</p><pre>package com.muratdayan.onboardingscreen<br><br>import android.os.Bundle<br>import android.widget.Toast<br>import androidx.activity.ComponentActivity<br>import androidx.activity.compose.setContent<br>import androidx.activity.enableEdgeToEdge<br>import androidx.compose.foundation.background<br>import androidx.compose.foundation.layout.Arrangement<br>import androidx.compose.foundation.layout.Box<br>import androidx.compose.foundation.layout.Column<br>import androidx.compose.foundation.layout.fillMaxSize<br>import androidx.compose.foundation.layout.padding<br>import androidx.compose.material3.MaterialTheme<br>import androidx.compose.material3.Scaffold<br>import androidx.compose.material3.Surface<br>import androidx.compose.material3.Text<br>import androidx.compose.runtime.Composable<br>import androidx.compose.runtime.rememberCoroutineScope<br>import androidx.compose.ui.Alignment<br>import androidx.compose.ui.Modifier<br>import androidx.compose.ui.platform.LocalContext<br>import androidx.compose.ui.tooling.preview.Preview<br>import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen<br>import com.muratdayan.onboardingscreen.onboarding.OnBoardingScreen<br>import com.muratdayan.onboardingscreen.onboarding.OnBoardingUtils<br>import com.muratdayan.onboardingscreen.ui.theme.OnBoardingScreenTheme<br>import kotlinx.coroutines.launch<br><br>class MainActivity : ComponentActivity() {<br><br>    private val onBoardingUtils by lazy {<br>        OnBoardingUtils(this)<br>    }<br><br>    override fun onCreate(savedInstanceState: Bundle?) {<br>        super.onCreate(savedInstanceState)<br><br>        installSplashScreen()<br><br>        setContent {<br>            OnBoardingScreenTheme {<br>                Surface(<br>                    color = MaterialTheme.colorScheme.background<br>                ) {<br>                    if(onBoardingUtils.isOnBoardingComplete()){<br>                        ShowHomeScreen()<br>                    }else{<br>                        ShowOnBoardingScreen()<br>                    }<br>                }<br>            }<br>        }<br>    }<br><br>    @Composable<br>    private fun ShowHomeScreen(){<br>        Column(<br>            modifier = Modifier.fillMaxSize(),<br>            verticalArrangement = Arrangement.Center,<br>            horizontalAlignment = Alignment.CenterHorizontally<br>        ){<br>            Text(text = &quot;Home Screen&quot;, style = MaterialTheme.typography.headlineLarge)<br>        }<br>    }<br><br><br>    @Composable<br>    private fun ShowOnBoardingScreen(){<br>        val scope = rememberCoroutineScope()<br><br>        OnBoardingScreen {<br>            onBoardingUtils.setOnBoardingComplete()<br>            scope.launch {<br>                setContent {<br>                    ShowHomeScreen()<br>                }<br>            }<br>        }<br>    }<br><br>}</pre><p><strong>Sonuç</strong></p><p>Onboarding sayfaları, yeni kullanıcıların bir ürün, hizmet veya uygulamayı etkili bir şekilde kullanmaya başlamaları için kritik bir öneme sahiptir. İlk izlenimden kullanıcı eğitimine, kullanıcı bağlılığının artırılmasından veri toplamaya kadar birçok alanda önemli rol oynarlar. İyi tasarlanmış bir onboarding süreci, kullanıcıların ürününüzü anlamalarını ve benimsemelerini sağlar, böylece kullanıcı memnuniyeti ve sadakati artar. Ayrıca, kullanıcıların sık karşılaştığı sorunları azaltarak destek taleplerini düşürür ve dönüşüm oranlarını iyileştirir. Kullanıcı verilerini toplayarak kişiselleştirilmiş deneyimler sunmanıza yardımcı olurken, ürününüzün değerini ve faydalarını hızlı bir şekilde göstermeyi mümkün kılar. Sonuç olarak, kullanıcı dostu ve yönlendirici onboarding sayfaları, hem kullanıcı deneyimini hem de iş hedeflerinizi destekleyerek başarınızı artırır.</p><p>Okuduğunuz için Teşekkürler:)</p><p>Bir dahaki yazıda görüşmek üzere… Happy Coding…</p><p>Source Code:</p><blockquote><a href="https://github.com/murat-dayan/OnBoardingPagesWithJetpackCompose">https://github.com/murat-dayan/OnBoardingPagesWithJetpackCompose</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac00c806752e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrating from XML to Jetpack Compose in Android]]></title>
            <link>https://medium.com/@muratdayan359/migrating-from-xml-to-jetpack-compose-in-android-64054c82aa87?source=rss-36dbfa40b935------2</link>
            <guid isPermaLink="false">https://medium.com/p/64054c82aa87</guid>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[xml]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Muratdayan]]></dc:creator>
            <pubDate>Sun, 09 Jun 2024 20:30:53 GMT</pubDate>
            <atom:updated>2024-06-30T11:16:07.766Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j2yVBXqK6W8__2VywwbFsg.png" /></figure><p>Merhabalar!</p><p>Bu yazıda, XML ve Jetpack Compose’un birlikte nasıl kullanılabileceğini ele alacağız. Yıllardır Android UI geliştirme denince akla ilk gelen XML, modern kullanıcı arayüzleri oluşturmanın temel taşlarından biri olmuştur. Ancak, Jetpack Compose’un getirdiği yeniliklerle, kullanıcı arayüzleri oluşturmak artık daha verimli ve esnek hale geldi. Bu yazıda, her iki yöntemi de aynı projede kullanarak nasıl geçiş yapabileceğinizi anlatacağım. Hadi başlayalım!</p><h3>1. Bağımlılıklar</h3><p>Öncelikle projemize aşağıdaki bağımlılıkları ekleyelim. build.gradle (module) dosyanıza şunları ekleyin:</p><pre>dependencies {<br>    implementation &quot;androidx.compose.ui:ui:x.x.x&quot;<br>    implementation &quot;androidx.compose.material:material:x.x.x&quot;<br>    implementation &quot;androidx.compose.ui:ui-tooling-preview:x.x.x&quot;<br>    implementation &quot;androidx.lifecycle:lifecycle-runtime-ktx:x.x.x&quot;<br>    implementation &quot;androidx.activity:activity-compose:x.x.x&quot;<br>}</pre><blockquote>Kullanmak istediğiniz sürümleri x.x.x kısımlarına yazabilirsiniz.Örneğin</blockquote><pre>implementation &quot;androidx.compose.ui:ui:1.1.1&quot;</pre><h3>2. Compose’u Etkinleştirme</h3><p>build.gradle (module) dosyanızda, android bloğu içine şu kodu ekleyerek Compose’u etkinleştirin:</p><pre>android {<br>    ...<br>    buildFeatures {<br>        compose true<br>    }<br>    composeOptions {<br>        kotlinCompilerExtensionVersion &#39;x.x.x&#39;<br>    }<br>}</pre><p>Burada kullandığınız kotlinCompilerExtensionVersion versiyonunun projenizdeki Kotlin sürümüyle uyumlu olması gerekiyor. Uyumlu sürümleri kontrol etmek için <a href="https://developer.android.com/jetpack/androidx/releases/compose-kotlin">bu siteyi</a> ziyaret edebilirsiniz.</p><h3>Kotlin 2.0.0+ Sürümü için Compose’u Etkinleştirme</h3><p>Kotlin 2.0.0+ sürümü kullanıyorsanız, uyumlu Compose sürümleri için bir plugin eklemeniz gerekiyor. libs.version.toml dosyanıza şu satırları ekleyin:</p><pre>[versions]<br>kotlin = &quot;2.0.0&quot;<br>[plugins]<br>org-jetbrains-kotlin-android = { id = &quot;org.jetbrains.kotlin.android&quot;, version.ref = &quot;kotlin&quot; }<br>// Add this line<br>compose-compiler = { id = &quot;org.jetbrains.kotlin.plugin.compose&quot;, version.ref = &quot;kotlin&quot; }</pre><p>Ardından, build.gradle (project) dosyasındaki plugins kısmına şu satırı ekleyin:</p><pre>plugins {<br>   // Existing plugins<br>   alias(libs.plugins.compose.compiler) apply false<br>}</pre><p>build.gradle (module) dosyasındaki plugins kısmına ise şu satırı ekleyin:</p><pre>alias(libs.plugins.compose.compiler)</pre><p>Son olarak, aynı dosyada herhangi bir kod bloğu içerisine girmeden şu satırı ekleyin:</p><pre>composeCompiler {<br>    enableStrongSkippingMode = true<br>}</pre><blockquote>Bu işlemleri tamamladıktan sonra composeOptions { kotlinCompilerExtensionVersion &#39;x.x.x&#39; } kod bloğuna ihtiyacınız kalmaz ve bunu silebilirsiniz.</blockquote><h3>3. XML Layout İçinde Compose View Kullanma</h3><p>XML layout’unuzda TextView veya Button bileşenlerini ekler gibi ComposeView bileşenini ekleyip ID verelim:</p><pre>&lt;androidx.compose.ui.platform.ComposeView<br>    android:id=&quot;@+id/composeView&quot;<br>    android:layout_width=&quot;match_parent&quot;<br>    android:layout_height=&quot;wrap_content&quot; /&gt;</pre><p>Bu XML’in bağlı olduğu Activity veya Fragment dosyanıza gidip, ComposeView bileşenine ID üzerinden ulaşıp setContent ile Compose bileşenlerimizi ekranda gösterebiliriz:</p><pre>val composeView: ComposeView = findViewById(R.id.composeView)<br>composeView.setContent {<br>    var text by remember { mutableStateOf(&quot;Hello, World!&quot;) }<br>Column(<br>        modifier = Modifier<br>            .fillMaxSize()<br>            .padding(16.dp),<br>        verticalArrangement = Arrangement.Center,<br>        horizontalAlignment = Alignment.CenterHorizontally<br>    ) {<br>        Text(<br>            text = text,<br>            fontSize = 24.sp<br>        )<br>        Button(onClick = { text = &quot;Button Clicked&quot; }) {<br>            Text(&quot;Click Me&quot;)<br>        }<br>    }<br>}</pre><h3>4. Fragment Üzerinden Compose Tasarımı</h3><p>Fragment içinde Compose View kullanarak XML’e olan bağımlılığınızı tamamen ortadan kaldırabilirsiniz. Örneğin:</p><pre>class LoginComposeFragment : Fragment() {<br>private lateinit var composeView: ComposeView<br>    <br>    override fun onCreateView(<br>        inflater: LayoutInflater, container: ViewGroup?,<br>        savedInstanceState: Bundle?<br>    ): View {<br>        return ComposeView(requireContext()).also { it -&gt;<br>            composeView = it<br>        }<br>    }<br>}</pre><p>Bu şekilde ComposeView&#39;i Fragment’a bağlarsanız, bu fragmentin XML dosyasını kullanmanıza gerek kalmaz ve XML dosyasını silebilirsiniz.</p><h3>Sonuç</h3><p>XML’den Jetpack Compose’a geçiş, daha temiz koddan daha iyi performansa kadar birçok avantaj sunar. Aşamalı bir migration stratejisi izleyerek, Jetpack Compose’un tüm potansiyelinden yararlanabilirsiniz. Okuduğunuz için teşekkürler!</p><p>Umarım bu yazı sizin için faydalı olmuştur. Jetpack Compose ile geliştirme yaparken iyi çalışmalar!</p><p><strong>Kaynaklar</strong></p><ul><li><strong>Android Developers Jetpack Compose Documentation</strong>: Jetpack Compose hakkında resmi dökümantasyon ve rehberler sağlar.</li></ul><p><a href="https://developer.android.com/develop/ui/compose">https://developer.android.com/develop/ui/compose</a></p><ul><li><strong>Android Developers Guide for Kotlin and Compose Compatibility</strong>: Kotlin sürümleri ile Compose uyumluluğunu kontrol etmek için kullanılabilir.</li></ul><p><a href="https://developer.android.com/jetpack/androidx/releases/compose-kotlin">https://developer.android.com/jetpack/androidx/releases/compose-kotlin</a></p><ul><li><strong>Jetpack Compose Pathway on Android Developers</strong>: Jetpack Compose ile ilgili eğitimler ve örnek projeler içerir.</li><li><a href="https://developer.android.com/courses/jetpack-compose/course">https://developer.android.com/courses/jetpack-compose/course</a></li><li><strong>JetBrains Kotlin Blog</strong>: Kotlin ve Jetpack Compose hakkında güncellemeler ve makaleler sunar.</li><li><a href="https://blog.jetbrains.com/kotlin/">https://blog.jetbrains.com/kotlin/</a></li><li><strong>Google Codelabs</strong>: Jetpack Compose ile ilgili interaktif eğitimler ve uygulamalar sağlar.</li><li><a href="https://developer.android.com/codelabs/jetpack-compose-migration#3">https://developer.android.com/codelabs/jetpack-compose-migration#3</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64054c82aa87" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>