<?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 Yunus Emre Çakıcı on Medium]]></title>
        <description><![CDATA[Stories by Yunus Emre Çakıcı on Medium]]></description>
        <link>https://medium.com/@yunuscakici.08?source=rss-4d6270a329d7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YCillp0hX5Rp28OtMVEuJg.png</url>
            <title>Stories by Yunus Emre Çakıcı on Medium</title>
            <link>https://medium.com/@yunuscakici.08?source=rss-4d6270a329d7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 13:35:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yunuscakici.08/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[Bir APK Nasıl Çalışır ?]]></title>
            <link>https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-7ebc599b4f34?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ebc599b4f34</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[apps]]></category>
            <category><![CDATA[apk]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Thu, 23 Oct 2025 17:46:58 GMT</pubDate>
            <atom:updated>2025-10-23T17:46:58.461Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bir APK Nasıl Çalışır ?</h3><h4>Part 3 — APK’dan Ekrana: Uygulama Yüklenmesi ve Başlatılması</h4><p>Bu yazı, <strong>“Bir APK Nasıl Çalışır?”</strong> serimizin son ve en kritik bölümüdür. Serinin ilk iki yazısına ulaşmak için:</p><ol><li><strong>Bir APK’nın Anatomisi: O Dosyanın İçinde Ne Var?</strong> <strong>:</strong> <a href="https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-6a70f39dd4c1"><strong>BURADAN ERİŞEBİLİRSİNİZ</strong></a></li><li><strong>Kaynak Kodu APK’ya Nasıl Dönüşür? (Derleme, DEX ve ART) </strong>: <a href="https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-8edb1d614ebb"><strong>BURADAN ERİŞEBİLİRSİNİZ</strong></a></li></ol><p>Artık APK’nın statik yapısını ve derlenme aşamasını bildiğimize göre, uygulamanın çalışmaya başlama anına odaklanalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9YXNLukenRAKHQdIkNAFeg.png" /></figure><p>Bir APK artık hazırdır ve cihazın depolama alanında güvenli bir şekilde beklemektedir. Ancak bir kullanıcının uygulama simgesine dokunmasıyla başlayan süreç, basit bir dosya açmaktan çok daha fazlasıdır. Bu son yazıda, o statik APK dosyasının dinamik, çalışan bir mobil uygulamaya dönüşme anını inceleyeceğiz. <strong>Uygulama Yüklenmesi (Installation)</strong> sırasında devreye giren Paket Yöneticisi’nin doğrulama adımlarından, uygulamanın çalışması için <strong>Zygote</strong> sürecinden nasıl türediğine kadar her aşamayı ele alacağız. Bir uygulamanın <strong>Android Runtime (ART)</strong> üzerinde bir sürece dönüşmesi, ana aktivitesinin başlatılması ve ekranda belirmesiyle sonuçlanan bu son ve en kritik adımlara odaklanacağız.</p><blockquote><strong>APK’nın Cihaza Yüklenmesi</strong></blockquote><p>APK dosyasını örneğin Google Play Store’dan indirip kur dediğinizde veya geliştirici olarak <strong>adb install</strong> komutuyla yüklediğinizde Android sisteminde Package Installer / PackageManagerService devreye girer. Bu yükleme sürecinde şu işlemler gerçekleştirilir:</p><p>1. <strong>İmza ve Bütünlük Kontrolü:</strong> Sistem, APK dosyasını aldığında önce META-INF klasörünü kontrol ederek paketin bozulup bozulmadığını ve imzasının geçerli olup olmadığını inceler. Daha önce bahsettiğimiz hash ve sertifika kontrolleri burada otomatik olarak yapılır. Eğer bir tutarsızlık tespit edilirse (örneğin dosya bütünlüğü bozulursa veya imza farklıysa) yükleme işlemi reddedilir.</p><p>2. <strong>APK’nın Kopyalanması:</strong> Kontrolü geçen APK, sistemde uygulamalara ayrılmış dizine kopyalanır. Genelde bu dizin /data/app/ altında bulunur (her uygulama için ayrı bir alt klasör oluşturulur, örneğin /data/app/com. example. myapp-abc123/base. apk şeklinde). APK dosyası buraya kopyalandıktan sonra genellikle salt-okunur bir biçime getirilir.</p><p>3. <strong>UID ve Sandbox Oluşturma:</strong> Android, her uygulama için yükleme sırasında ayrı bir Linux kullanıcı kimliği (UID) oluşturur. Bu sayede uygulama kendi çalışma ortamında izole bir şekilde çalışır (sandbox). Uygulamaya özel veri dizini ( /data/data// ) oluşturulur ve bu dizine yalnızca o UID’ye sahip olan işlemler erişebilir. Bu sistem, uygulamaların birbirlerinin verilerine erişimini engelleyerek güvenlik sağlamaktadır. Örneğin, com. example. myapp uygulamasının UID’si 10067 ise, verileri /data/data/com. example. myapp/ dizininde tutulur ve başka uygulamalar bu dosyalara erişemez.</p><p>4. <strong>DEX Optimizasyonu (ODEX/AOT):</strong> Eğer cihaz ve Android sürümü AOT derlemeyi destekliyorsa, yükleme sırasında dex2oat çalışarak APK içindeki DEX dosyalarını derleyip optimize edebilir. Bunun sonucunda ortaya çıkan .oat ve .vdex dosyaları ya uygulamaya özel dizine ya da sistemin dalvik-cache alanına yazılır (genellikle /data/dalvik-cache/. . . altında). Bu adım, uygulamanın daha sonra hızlı bir şekilde açılabilmesi için yapılan bir optimizasyondur. Ancak yeni Android sürümlerinde bu aşama genellikle minimal tutulur (ilk açılışta gerçekleştirilir) denilen PGC stratejisi doğrultusunda. Yine de, burada küçük bir profil AOT derlemesi veya doğrulama yapılması mümkün olabilir.</p><p>5. <strong>Kayıt ve Son Hazırlıklar:</strong> Package Manager, yüklenen uygulamayı sistemde kaydeder. Uygulamanın manifest dosyasından paket adı, versiyonu, bildirdiği izinler, servisler gibi bilgileri alarak sistemin uygulama listesine ekler. Launcher (cihazın ana ekran uygulaması) bu yeni uygulamanın simgesini alıp uygulama menüsüne ekler. Artık kullanıcı, uygulamayı görebilir ve başlatabilir. Yani, yükleme süreci sona erdiğinde, uygulama dosyası yerinde, imzası doğrulanmış, sistem kaydı yapılmış ve gereken optimizasyonlar (UID ataması, dex optimize gibi) tamamlanmış olur.</p><p>Yükleme aşaması güvenlik kontrolleri ve hazırlık adımlarıyla dolu olmasına rağmen, kullanıcı sadece “Yükleniyor. . . ” çubuğunu ve ardından “Uygulama yüklendi” mesajını görür. Biz bu durumu kısaca böyle özetledik. Şimdi asıl konumuza geçelim: Kullanıcı uygulama simgesine tıkladığında ne yaşanır? Uygulamamız nasıl çalışmaya başlar? Bunu şimdi adım adım inceleyelim.</p><blockquote><strong>Uygulamanın Başlatılması (Launch)</strong></blockquote><p>Android’de bir uygulamanın başlatılması, işletim sisteminin temelinden kullanıcının etkileşimde bulunduğu arayüze kadar bir dizi bileşenin iş birliği gerektirir. Bu durumu daha net bir şekilde açıklamak için bir örnek üzerinden ilerleyelim.</p><p>1. <strong>Kullanıcı Talebi:</strong> Kullanıcı ana ekranındaki uygulama simgesine dokunur. Bu hareket, bir başlatma isteği oluşturur. Launcher uygulaması, Android’in ana merkezi olan ActivityManagerService (AMS) sistemine “belirtilen paketin ana aktivitesini başlat” komutunu gönderir.</p><p>2. <strong>Süreç Kontrolü:</strong> ActivityManagerService (AMS), önce söz konusu uygulamanın çalışıp çalışmadığını kontrol eder. Çünkü Android, her açılışta yeni bir süreç başlatmak yerine, uygulamanın daha önce bir süreçte aktif olup olmadığını tespit ederek (örneğin arka planda duraklatılmış olabilir) mevcut süreci kullanabilir. Eğer mevcut süreç çalışıyorsa (örneğin arka planda bekliyor ama sonlandırılmamışsa), yeni bir süreç oluşturmaya gerek kalmaz. Mevcut sürece ilgili aktiviteler dahil edilir ve yalnızca gerekli olan onResume() gibi metotlar çağrılır. Bu durumda Application. onCreate gibi diğer işlemler yeniden tetiklenmez.</p><p>Eğer uygulamanın süreci yoksa (daha önce hiç başlatılmamış veya sonlandırılmışsa): Yeni bir süreç başlatılması gerekecektir. Bu durumda bir sonraki aşamaya geçeriz.</p><p>3. <strong>Zygote ile Yeni Süreç Oluşturma: </strong>Tüm Android uygulama süreçleri, Zygote adlı bir işlemden türetilir. Zygote, Android sistemi başlatıldığında çalışan, içinde bir Dalvik/ART sanal makinesi ile temel kütüphaneler ve framework’ü önceden yüklenmiş olan bir şablon süreçtir. AMS yeni bir uygulama başlatmayı istediğinde, Zygote’a bir sinyal yollamak için Unix domain socket üzerinden “fork” komutunu kullanır. Zygote, bunun üzerine kendini fork() sürecine tabi tutar, yani kendisinden bir kopya çıkarır. Bu kopya, yeni uygulamanın sürecini oluşturacaktır. Fork ile yaratılan bu çocuk süreç, ebeveyn Zygote’un hafızasından bir kısmını kullanarak başlar (Copy-on-Write ile başlangıçta bellek paylaşılır). Yeni süreç, kendine dair özel bir UID (önceden atanmış) ve SELinux güvenlik bağlamını alır, böylece kendi sandbox’ında çalışmaya başlar. Zygote’un bu yapısı sayesinde uygulama süreçleri hızlı bir şekilde başlatılabilir (Linux’ta fork çağrısı oldukça etkilidir) ve bellek kullanımı daha verimlidir, çünkü zaten yüklü olan temel kütüphaneler ve framework sınıfları yeni sürece direkt olarak aktarılır. Zygote hakkında şöyle düşünebilirsiniz: Cihaz açılırken ilk olarak “Java VM + Android Framework” oluşturulmakta, sonrasında her yeni uygulama bunun kopyası olarak hızla üretilmektedir. Eğer Zygote olmasaydı, her uygulama için sıfırdan bir VM ve kütüphane yüklemesi yapılacağı için uygulamalar daha yavaş açılacaktı.</p><p>4. <strong>ART’nin Başlatılması:</strong> Zygote’tan türeyen yeni uygulama sürecinde, artık yalnızca bizim uygulamamıza özgü işlemler başlamakta. Bu yeni aşamada, Android Runtime (ART) Zygote’tan aldığı miras sayesinde hazır durumda, fakat uygulamanın kendi DEX kodunu yüklemesi gerekiyor. Bu noktada ART, uygulamamızın classes.dex dosyasını erişilebilir duruma getirir (class loader ayarlanır). Eğer yükleme sırasında AOT derlemesi yapılmışsa ve bir .oat dosyası oluşturulmuşsa, ART bu dosyayı doğrudan belleğe yerleştirerek yükleyebilir; yoksa .dex dosyasını belleğe alarak gerekli durumda JIT derlemesi yapmaya hazır hale getirir. Yani sanal makine ortamı, uygulamanın kodunu çalıştırmak için hazırlanır. Bu arada Android’in ana uygulama iş parçacığı (Main Thread) da başlatılır: yeni süreç içerisinde ActivityThread adlı sınıfın main() metodu çağrılarak, uygulamanın ana iş parçacığı ve Looper’ı (olay döngüsü) çalışmaya başlamaktadır. ActivityThread, Android çerçevesinin her uygulamada bulunan ve kullanıcı arayüzü iş parçacığını yöneten bileşenidir. Bu iş parçacığı oluşturulduktan sonra bir sonraki aşamaya geçeriz.</p><p>5. <strong>Uygulama Nesnesinin Oluşturulması:</strong> Android uygulamalarında, her uygulama için (proses özel olarak) bir Application sınıfı mevcuttur. Biz özel bir Application sınıfı tanımlamasak da, android.app.Application sınıfı varsayılan olarak kullanılır. Uygulama başladığında, ART, AndroidManifest.xml dosyasındaki etiketine bakarak özelleştirilmiş bir Application sınıfının tanımlanıp tanımlanmadığını kontrol eder. Eğer böyle bir sınıf belirtilmişse, o sınıf yüklenir; aksi halde varsayılan Application sınıfı devreye girer. Daha sonra, yeni süreçteki ActivityThread, bu Application sınıfının bir örneğini oluşturur. Yani programatik olarak Application app = new MyApplication(); gibi bir işlem gerçekleşiyor demek mümkün. Bu nesne, uygulamanın genel durumunu saklar ve uygulama yaşam döngüsünde kritik bir öneme sahiptir.</p><p>6. <strong>Application.onCreate() ve İlk Activity:</strong> Application nesnesi oluşturulduktan hemen sonra, uygulamanın başlangıç noktası olarak kabul edilen Application. onCreate() metodu çağrılır. Eğer geliştirici bu metodu kendi Application sınıfında geçersiz kıldıysa, genellikle uygulama genelindeki gerekli başlatma işlemleri burada gerçekleştirilir (örneğin veritabanının açılması, analizlerin başlatılması gibi) .onCreate metodu tamamlandıktan sonra, AMS’nin talebi doğrultusunda asıl başlatılmak istenen Activity (genellikle MainActivity) oluşturulur ve onun yaşam döngüsü başlatılır (Activity.onCreate(), .onStart(), .onResume sırası ile). Bu aşamadan itibaren kullanıcı, uygulamanın arayüzünü görmeye başlar. Bu görünürlük, Activity’nin View hiyerarşisinin (Layout XML’lerinden oluşturulan) Pencere Yöneticisi (Window Manager) tarafından ele alınması ve son olarak SurfaceFlinger adı verilen sistem servisinin yardımıyla grafik donanımı tarafından piksellerin ekrana çizilmesiyle sağlanır. Uygulamanın başlatılması, kodun çalışmasından piksellerin ekranda belirmesine kadar uzanan tam bir döngüyle sona ermiş olur.</p><p>Yukarıdaki adımlar tamamlandığında, uygulama kullanılmaya hazır hale gelir. Kullanıcı etkileşimde bulunabilir, butonlara basabilir ve yazdığımız kodlar olaylara yanıt verebilir. Bu işlemler biraz uzun görünebilir, ancak Android’in optimizasyon sistemleri sayesinde (özellikle Zygote forku sayesinde) genellikle birkaç yüz milisaniye ile bir iki saniye içinde bu aşamalar tamamlanır ve uygulama ekranda belirebilir. Modern cihazlar ve iyi optimize edilmiş uygulamalarla açılış süreci oldukça hızlıdır.</p><p>Bir ek bilgi olarak, Android, bir cihazda aynı anda birden fazla uygulamayı bellekte tutabilir; fakat görünüşte genellikle yalnızca bir tanesi aktif durumdadır. AMS, sistem kaynakları azaldığında arka plandaki uygulamaların süreçlerini sonlandırabilir. Böyle bir durumda kullanıcı o uygulamaya döndüğünde yukarıda bahsedilen süreci yeniden yaşar (yani süreç yeniden oluşturulur, Application. onCreate tekrar çağrılır). Ancak eğer uygulamanın süreci arka planda kalmışsa ve kullanıcı tekrar açarsa, Android aynı süreci kullanır ve yalnızca ilgili Activity’nin onResume’u çağrılır; Application.onCreate tekrar çalışmaz çünkü süreç zaten mevcuttur.</p><p>Tüm bunlar, “Bir APK nasıl çalışır? ” sorusunun yanıtını bize sunmaktadır: APK dosyası içerisindeki tanımlı bileşenler, Android işletim sistemi tarafından önce güvenli bir biçimde cihaza yüklenmektedir, ardından kullanıcı uygulamayı başlattığında Zygote mekanizmasıyla hızlıca bir işlem oluşturulur ve ART aracılığıyla DEX kodu çalıştırılarak uygulamanın yaşam döngüsü başlamaktadır.</p><p>Üç bölümden oluşan bu serüvenimizde, bir Android uygulamasının geliştiricinin kod satırlarından, cihazımızda çalışan dinamik bir sürece dönüşümüne tanıklık ettik. Yolculuğumuz, bir uygulamanın DNA’sı olan statik <strong>APK dosyasının yapısını</strong> incelemekle başladı (Part 1). Ardından, kaynak kodun mobil için optimize edilmiş <strong>DEX bayt koduna</strong> dönüştüğü ve <strong>Android Runtime (ART)</strong> tarafından nasıl verimli bir şekilde yürütüldüğü (JIT, AOT) gibi karmaşık <strong>Derleme Süreçlerini</strong> analiz ettik (Part 2).</p><p>Ve nihayet, bu son bölümde (Part 3), kullanıcının simgeye dokunmasıyla başlayan anlık sistem reaksiyonunu, <strong>Paket Yöneticisi’nin</strong> güvenlik adımlarını, <strong>Zygote</strong>’un hızlı süreç oluşturma mekanizmasını ve <strong>ActivityManagerService’in</strong> uygulamanın yaşam döngüsünü nasıl yönettiğini detaylıca öğrendik.</p><p>Artık basit bir uygulama yükleme eyleminin arkasında, her bir uygulamanın izole ve güvenli çalışmasını sağlayan <strong>Sandbox</strong> mimarisinden, sistem kaynaklarını en verimli şekilde kullanan <strong>ART ve Zygote</strong> stratejilerine kadar uzanan bir mühendislik harikası yattığını biliyorsunuz.</p><p>Bir <strong>APK</strong>, sadece bir dosya değil; Android’in çekirdeği ile kusursuz bir uyum içinde çalışan, karmaşık ve optimize edilmiş bir yapı bütünüdür.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ebc599b4f34" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bir APK Nasıl Çalışır ?]]></title>
            <link>https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-8edb1d614ebb?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/8edb1d614ebb</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[apk]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[apps]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Thu, 23 Oct 2025 17:20:13 GMT</pubDate>
            <atom:updated>2025-10-23T17:48:56.141Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bir APK Nasıl Çalışır ?</h3><h4>Part 2 — Kaynak Kodu APK’ya Nasıl Dönüşür? (Derleme, DEX ve ART)</h4><p>Bu yazı, <strong>“Bir APK Nasıl Çalışır?”</strong> serimizin ikinci bölümüdür. Serinin ilk bölümü olan <strong>“APK’nın Anatomisi: O Dosyanın İçinde Ne Var?”</strong> yazısına <a href="https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-6a70f39dd4c1"><strong>BURADAN ERİŞEBİLİRSİNİZ</strong></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z6GjTktiJPWpq3uJzEr7fw.png" /></figure><p>İlk yazımızda bir APK’nın içindeki bileşenleri öğrendik. Peki bir geliştiricinin yazdığı insan diline yakın kodlar, o APK’nın kalbi olan ve Android’in çalıştırabileceği özel <strong>DEX bayt koduna</strong> nasıl dönüşüyor? Bu süreç, geliştirme ortamındaki derlemeden, Android Runtime (ART) ile uyumlu hale getirilmeye kadar giden karmaşık bir yolculuk içerir. Bu yazıda, kaynak kodun APK dosyasında yer alan çalıştırılabilir forma nasıl dönüştüğünü; <strong>ART</strong>’nin performans için neden kritik olduğunu ve <strong>DEX</strong> bayt kodunun geleneksel Java bayt kodundan farkını inceleyeceğiz. Kodunuzun cihaza hazır hale gelmesini sağlayan bu kritik aşamaların perde arkasını aydınlatacağız.</p><p>Şimdi, geliştirme ortamımızda yazdığımız kodu, bir önceki yazımızda incelediğimiz o kompakt APK yapısına dönüştüren <em>büyülü</em> süreci, yani <strong>Android Derleme Aşamasını</strong> adım adım inceleyelim:</p><blockquote><strong><em>Kaynak Kodların Derlenmesi (Java/Kotlin →. class):</em></strong></blockquote><p>Uygulamamızın ana dizisi genellikle Java (.java) ya da Kotlin (.kt) uzantılı dosyalarla yazılır. İlk basamakta bu kaynak kodlar Java derleyicisi (javac) tarafından işlenir. Bu derleme işlemi sonucunda her bir sınıf için ayrı .class dosyaları oluşturulur. .class dosyaları, Java Sanal Makinesi (JVM) için bayt kodunu taşır; yani platformdan bağımsız, derlenmiş ama henüz Android’e özgü olmayan bir kod yapısındadır. Bu aşamada uygulamanın lojik kodu derlenmiş olsa da, Android cihazında doğrudan çalıştırılamayacaktır çünkü Android, JVM kullanmaz.</p><blockquote><strong><em>JVM Bytecode’unun DEX Formatına Dönüştürülmesi (.class → classes.dex):</em></strong></blockquote><p>İkinci aşamada, Android’in temel taşlarından biri olan özel derleyici aracı <strong>D8</strong> (eski adıyla dx), devreye girer. Android, .class dosyalarını doğrudan kullanmak yerine bunları DEX (Dalvik Executable) formatına dönüştürür. Bu işi önceden dx aracı üstlenirken, modern araç dizisinde D8 derleyicisi bunu gerçekleştirir. D8, derlenmiş tüm .class dosyalarını toplar, birleştirir ve optimize eder; sonuç olarak tek bir classes.dex dosyası oluşturur. (Eğer uygulamanız çok büyükse, D8 birden fazla DEX dosyası da oluşturabilir — buna MultiDex denir — ancak mantık aynıdır. ) Bu aşamada birden fazla .class içinde tekrar eden veriler (örneğin, aynı metin dizileri, sınıf adları) ayıklanarak sadeleştirilir, gereksiz boşluklar temizlenir ve mobil cihazda çalışabilen kompakt bir bayt kodu elde edilir. Neden böyle bir dönüştürme yapıldığı sorulursa: DEX formatı, mobil cihazların sınırlı bellek ve işlem gücünü göz önünde bulundurarak tasarlanmıştır. Tüm kodun tek bir dosyada toplanması, uygulama yüklenirken birçok küçük dosya yerine tek bir dosyanın yüklenmesini sağlar; bu da hem disk okuma işlemini hem de bellek kullanımını azaltır. Ayrıca, DEX, bir uygulamadaki tüm sınıfları ve metotları global bir indeksle numaralandırdığı için, çalışma zamanında sınıf yükleme ve metod çağırma gibi işlemler JVM formatına göre daha etkili bir şekilde gerçekleşir. Bu dönüşüm sayesinde, kodumuz artık Android cihazın ART/Dalvik sanal makinesinin yürütebileceği bir formata ulaşmış olur. Peki Nedir bu ART ?</p><p><strong><em>Android Runtime (ART)</em></strong></p><p>Android Runtime (ART), Android işletim sisteminin kalbinde yer alan ve uygulamaların çalıştırılmasından sorumlu olan kritik bir sanal makinedir (VM). ART’ın esas görevi, bu bayt kodunu cihazın anlayabileceği makine koduna dönüştürüp çalıştırmaktır. Bunu gerçekleştirmek için çeşitli yöntemler mevcuttur ve Android bu yöntemlerin bir kısmını yıllar içerisinde uygulamıştır:</p><p><strong>Önceden Derleme (AOT — Ahead-of-Time):</strong> ART’nin ilk sürümlerinde (Android 5–6), uygulama cihaza yüklendiğinde DEX kodu tamamen makine koduna çevriliyordu. Yani, bir APK yüklediğinizde Android arka planda dex2oat adlı bir derleyiciyi devreye sokar ve classes. dex içindeki bayt kodunu alıp cihazın CPU yapısına uygun saf makine kodu üretir. Bu makine kodu daha sonra .oat adlı bir dosyada depolanır (aynı zamanda, optimize ve veri tablosu içeren .vdex adıyla bilinen bir dosya da oluşur). Bu işleme AOT derleme deniyor çünkü uygulama çalışmadan evvel kod derlenmiş oluyor. Bunun artısı, kullanıcı uygulamayı açmak istediğinde ART’nin artık bayt kodunu çevirmesine gerek kalmaması ve doğrudan hazır makine kodunu yüklemesi, dolayısıyla uygulamanın oldukça hızlı açılmasıdır. Ancak dezavantajı, yükleme sırasında zaman almasıdır — APK kurulumu esnasında biraz daha uzun sürüyor zira arka planda derleme gerçekleşiyor ve ayrıca bu derlenmiş kod cihazın depolama alanında yer kaplıyor.</p><p><strong>Anında Derleme (JIT — Just-in-Time):</strong> Android 7. 0 (Nougat) ile birlikte ART, AOT’ye ek olarak JIT modunu da kullanmaya başladı. Bu modda, eğer. oat (önceden derlenmiş kod) mevcut değilse, uygulama ilk açılışta hemen çalıştırılır ve ihtiyaç duyulan kodlar sırayla derlenir. Yani ART, DEX bayt kodunu ilk önce yorumlayarak çalıştırmaya başlar. Uygulama çalışırken, sıkça kullanılan (“hotspot” olarak adlandırdığımız) metodları belirleyip bu metodları çalıştırma esnasında makine koduna çevirerek bellekte tutar. Böylece, uygulama ilk seferde belki bir miktar yavaş açılır ama sonraki kullanımlarda kritik fonksiyonlar derlenmiş olduğu için daha hızlı hale gelir. JIT’in avantajı, uygulamayı kurarken zaman kaybetmemek (çünkü derleme işlemi yükleme sırasında değil, çalışırken yapılır) ve cihazın depolama alanında tasarruf sağlamasıdır. Bunun yanı sıra, sistem, hangi kodun daha fazla kullanıldığını gerçek zamanlı olarak gözlemleyebildiğinden, en çok tercih edilen bölümleri optimize edip az kullanılanları derlemeyerek verimli bir denge ortaya koyar. Ancak dezavantajı, ilk açılışta bir gecikme yaşanması ve çalışma esnasında CPU’ya ek yük getirmesidir — uygulama çalışırken arka planda derleme yapıldığı için performansa küçük bir olumsuz etkisi olabilir.</p><p><strong>Profil Rehberliğinde Derleme (PGC — Profile-Guided Compilation):</strong> Android 7 ve sonrasında, ART aslında saf AOT veya saf JIT yerine her iki yöntemin birleşik bir stratejisini benimsemekte. Mantık şu şekildedir: Uygulama ilk yüklendiğinde tamamen AOT gerçekleştirmeyerek hızlı bir kurulum sağlamak, ilk seferde JIT ile devam etmektir. Programın tanımını çıkar, ardından cihaz uygun bir anda (örneğin gece şarja bağlıyken) arka planda en çok kullanılan kodları AOT yöntemiyle derle. Böylece, kullanıcı uygulamayı yüklerken çok beklemeyecek, uygulama ilk kez açıldığında makul bir hızda çalışacak ve kullanıcı uygulama süresince ART, hangi yöntemlerin sık kullanıldığını kavrayacak. Sonrasında sistem bu bilgiyi kullanarak önemli kodları derleyip kalıcı hale getirecek, daha az kullanılanları ise JIT/yorumlama ile bırakacak. Sonuç olarak, önemli kodlar optimize edildiği için performans artacak, gereksiz kodların derlenmemesi sayesinde de depolama ve bellek tasarrufu sağlanacak. Bu PGC sistemi, ART’yi oldukça akıllı bir çalışma zamanı haline getiriyor — kullanıcıya en iyi deneyimi sağlamak için derleme stratejisini uyarlıyor.</p><p>Özetle, ART şu an JIT ve AOT birleşimi bir yaklaşım izliyor. Uygulama kurulumunda belki çok az bir derleme yapıyor veya hiç yapmıyor, çalışma sırasında ise JIT ile hız kazanıyor. Arka planda ise profil bilgilerine dayanarak kalıcı optimizasyon gerçekleştiriyor. Böylece uygulamalar hızlı bir şekilde açılıyor ve sistem kaynakları etkin bir biçimde kullanılıyor. Ancak, bu süreçlerin çoğu göz önünde gerçekleşmiyor; biz yazılımcılar ya da son kullanıcılar bu belirli ayrıntıları pek fark etmiyoruz. Sadece uygulamanın hızını, pil tüketimini gibi sonuçları görebiliyoruz.</p><p>Önemli bir diğer husus, ART yalnızca DEX işlemleri yürütmekle kalmaz, aynı zamanda bellek yönetimi (Çöp Toplama), işletim sistemiyle etkileşim ve yerel kodların yüklenmesi (JNI) gibi birçok görevi de yerine getirir. Başka bir deyişle, Android Runtime uygulamanın yaşam döngüsünü yöneten, gerektiğinde C/C++ kütüphanelerini yükleyen ve Java ile Native kodlar arasında köprü görevi gören kapsamlı bir alt yapıdır. Bu altyapı sayesinde, uygulama kodunuz tamamen Java/Kotlin’de yazılmış olsa bile, bir kısım C++ ile yazılmış olsa bile, ART bunları sorunsuz bir şekilde çalıştırır. Çöp toplama işlemi ile belleği geri kazanır ve her uygulamayı ayrı bir sanal makine üzerinde güvenli ve izole bir şekilde tutar.</p><blockquote><strong><em>Kaynak Dosyaların Derlenmesi ve Paketlenmesi:</em></strong></blockquote><p>Kod kısmı .dex formatına dönüştürülürken, uygulamanın res/ dizinindeki kaynaklar AAPT (Android Asset Packaging Tool) aracıyla işlenir. AAPT (özellikle aapt2&#39;nin yeni versiyonu) derleme süresince kaynak dosyalarını inceleyerek, her birine benzersiz bir kimlik (ID) atar ve bu kaynakları ikili formata çevirip resources.arsc dosyasını oluşturur. Örneğin, strings. xml içinde yer alan hello_world metni için aapt bir ID üretir (örneğin, 0x7f0a000e). Ardından bu metnin değeri (“Merhaba Dünya! “) resources.arsc dosyasındaki tabloya kaydedilir. Bu işlem tüm kaynaklar için tekrarlanır; böylece uygulamanızın stringleri, renkleri ve layout XML’leri derlenip indekslenmiş olur. Ayrıca aapt, bu kaynak ID’lerini kullanarak R. java adlı bir sınıf oluşturur ki, kodunuza R.drawable.resim veya R.string.hello_world yazdığınızda hangi ID’ye karşılık geldiği bilinsin. Manifest dosyası da benzer bir şekilde derlenip (XML’den binary XML formatına) APK’ya eklenir. Eğer projenizde assets/ klasörü mevcutsa, buradaki dosyalar derlenmez ve olduğu gibi APK’ya ilave edilir. Son olarak, uygulamanın proguard veya şifreleme gibi ek süreçleri varsa (örneğin, kodun optimize edilmesi veya küçültülmesi), bunlar da bu aşamada uygulanır. Böylece hem kod hem de kaynaklar Android paketine dahil olmaya hazır hale gelir.</p><blockquote><strong><em>APK’nın Oluşturulması (Paketleme):</em></strong></blockquote><p>Kod ve kaynaklar hazırlanıp tamamlandıktan sonra, APK paketi oluşturulur. Bu aşamada toplanmış tüm bileşenler tek bir konteyner içinde birleştirilir. Android Gradle bu aşamada bir ZIP arşivi oluşturur ve içerisine: derlenmiş kod (classes.dex), derlenmiş kaynaklar (resources.arsc), derlenmiş manifest (AndroidManifest.xml), res/ dizinindeki sıkıştırılmış kaynak dosyaları (PNG, XML vb), assets/ klasöründeki içerik, mevcutsa lib/ altındaki .so dosyaları ve META-INF imza bilgilerini ekler. Ortaya çıkan paket .apk uzantısına sahiptir ve bir uygulamanın çalışması için gereken tüm dosyaları içerir. Yani bu aşamada artık cihazda yüklenip çalıştırılabilecek tek bir dosyamız vardır: MyApp. apk gibi.</p><blockquote><strong><em>APK’nın İmzalanması:</em></strong></blockquote><p>Paket oluşturulduktan sonra, APK’nın güvenli bir şekilde imzalanması gereklidir (genellikle bu işlem otomatik olarak gerçekleştirilir). Geliştirme sırasında Android Studio, APK’yı debug anahtarı ile imzalar; uygulamayı yayımlarken kendi özel sertifikanızla imzalama işlemini gerçekleştirirsiniz. Bu imza, bahsedilen META-INF klasöründeki dosyalar aracılığıyla APK’ya eklenmiştir. İmzasız bir APK, Android cihazına yüklenmez, bu nedenle bu adım zorunludur. İmzalama sürecinin detaylarına daha önce değinmiştik; APK içindeki her dosyanın bir özeti alınır, bu özet MANIFEST. MF dosyasına yazılır, ardından bu manifest dosyası geliştiricinin sertifikasıyla imzalanarak CERT. SF dosyasına konur ve sertifika bilgisi de CERT. RSA dosyası ile pakete dahil edilir. Nihayetinde, APK’nız hem bütünlük hem de kimlik doğrulama bilgileriyle birlikte kullanıma sunulur.</p><p>Bu derleme süreci tamamlandığında, güvenli bir şekilde imzalanmış ve çalışmaya hazır <strong>.apk</strong> dosyamız artık hazırdır. Serinin son yazısında ise, bu hazır paketin bir kullanıcının ekranına nasıl taşındığını göreceğiz: <strong>Paket Yöneticisi, Zygote ve Activity Manager üçgeninde Uygulama Yüklenmesi ve Başlatılması</strong> sürecini adım adım inceleyeceğiz.</p><p><a href="https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-7ebc599b4f34"><strong>Part 3 — APK’dan Ekrana: Uygulama Yüklenmesi ve Başlatılması</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8edb1d614ebb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bir APK Nasıl Çalışır ?]]></title>
            <link>https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-6a70f39dd4c1?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a70f39dd4c1</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android-apps]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[apk]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Thu, 23 Oct 2025 16:40:02 GMT</pubDate>
            <atom:updated>2025-10-23T17:22:16.186Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bir APK Nasıl Çalışır ?</h3><h4>Part 1 — Bir APK’nın Anatomisi: O Dosyanın İçinde Ne Var?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9_JJhQu89xkpOEWK9YC0Sg.png" /></figure><p>Mobil uygulamaların dağıtımının temeli olan APK (Android Paket) dosyası, bir Android uygulamasının tüm DNA’sını içinde barındıran standart bir arşividir. Bir uygulama geliştikten sonra markete yüklenmeye hazır hale gelirken, aslında bir dizi klasör ve özel dosyayı tek bir ZIP formatında paketler. <strong>Peki, bu arşivi açtığımızda bizi ne karşılıyor?</strong> Bu yazıda, bir APK dosyasının anatomisine inecek; kodları, görsel kaynakları, imzaları ve uygulamanın kimliği olan kritik AndroidManifest.xml dosyasını nerede bulduğumuzu adım adım inceleyerek, bu statik yapının bir uygulamanın temelini nasıl oluşturduğunu göstereceğiz.</p><blockquote><strong>Öncelikle APK nedir?</strong></blockquote><p>En basit tanımıyla, bir APK dosyası Android uygulamasının bütün bileşenlerini içeren tek bir dosyadır. Aslında bu dosya, özel olarak düzenlenmiş bir ZIP arşivi şeklindedir ve. apk uzantısını taşır. Yani bir APK’yı bir zip dosyası gibi açtığınızda, uygulamanın ihtiyaç duyduğu tüm dosya ve kaynakların bir arada bulunduğunu görebilirsiniz. Peki, bu dosyalar hangileridir?</p><p>Bir APK dosyasını incelemeye başladığımızda, karşılaştığımız temel bileşenleri şu şekilde sıralayabiliriz:</p><p>APK/</p><p>├── AndroidManifest.xml</p><p>├── classes.dex</p><p>├── resources.arsc</p><p>├── res/</p><p>│ ├── layout/</p><p>│ ├── drawable/</p><p>│ └── values/</p><p>├── assets/</p><p>├── lib/</p><p>│ ├── armeabi-v7a/</p><p>│ └── arm64-v8a/</p><p>└── META-INF/</p><p>├── MANIFEST.MF</p><p>├── CERT.RSA</p><p>└── CERT.SF</p><p>Şimdi bu bileşenlerin her birine daha yakından bakarak, bir uygulamanın kimliğini, kodlarını ve kaynaklarını nasıl barındırdığını detaylıca inceleyelim.</p><p><strong><em>AndroidManifest.xml</em></strong></p><p>Uygulamanın kimliğini ve yapı bileşenlerini belirten bir dosya. Bu dosyada paket adı (uygulamanın eşsiz ismi), uygulamanın talep ettiği izinler, içerdiği bileşenler (Activity, Service, BroadcastReceiver gibi), minimum SDK sürümü ve uygulamanın ikonu gibi detaylar yer alır. Kısacası, bu dosya uygulamanın temel belgelerinden biridir. Android işletim sistemi, bir APK yüklenirken önce bu manifest dosyasını analiz eder ve uygulamanın ismi, hangi izinleri istediği, hangi bileşenleri barındırdığı gibi bilgilere buradan ulaşır. Eğer bu dosya eksik ya da hatalıysa, APK yüklenemez (Install Parse Error hatası ortaya çıkar).</p><p><strong><em>classes.dex</em></strong></p><p>Uygulamanın derlenmiş çalıştırılabilir kodunu barındıran dosya. Bu dosya Dalvik Executable (DEX) formatında olup, Java ya da Kotlin dilleriyle yazdığımız kodların bytecode’a dönüştürülmüş hâlidir. Android aygıtlarında JVM yerine Dalvik/ART sanal makinesi çalıştığı için, geliştirdiğimiz uygulama kodlarının DEX formatında olması gerekmektedir. Genellikle tek bir classes. dex dosyası bulunur, ancak büyük uygulamalar birden fazla dex dosyasına sahip olabilir (classes2. dex, classes3. dex gibi, bu duruma multidex denir). classes. dex dosyasındaki bytecode, uygulama çalıştığında Android Runtime (ART) tarafından yüklenip çalıştırılır.</p><p><strong><em>resources.arsc</em></strong></p><p>Uygulamanın tüm kaynaklarının derlenmiş versiyonunu içeren dosya. Bu dosya, uygulamadaki metinler, renk tanımları, stil temaları gibi tüm yerelleştirilebilen kaynakların ikili (binary) formatında tutulmasına olanak tanır. Kaynakların tek bir dosya halinde ve derlenmiş biçimde bulunması, uygulamanın çalışması esnasında bu verilere hızlı bir şekilde erişilmesini sağlar. Örneğin, farklı dillerde ve ekran boyutlarındaki tüm metinler bu dosyada indekslenmiştir. Uygulama çalıştığında sistem, resources. arsc içindeki veri tablolarını belleğe yükler ve bir kimlik aracılığıyla istenen kaynağa hızlıca ulaşır. Bu yöntemle, metinlerin bir XML dosyasından ayrı ayrı okunmasına kıyasla erişim O(1) zaman karmaşıklığında, yani sabit süre içinde gerçekleşerek performansı artırır.</p><p><strong><em>res/ Dizini</em></strong></p><p>Uygulamanın sahip olduğu sabit kaynak dosyalarını barındıran klasör. Örneğin, kullanıcı arayüzü tanımları için XML dosyaları (layout/ alt klasöründe), uygulama içindeki görseller (drawable/ alt klasöründe PNG gibi), menüler, animasyon tanımlamaları ve values/ klasöründeki metinler, renkler, boyutlar burada bulunmaktadır. Derleme aşamasında bu res/ klasöründeki içerikler gözden geçirilir ve her birine bir kaynak kimliği verilerek daha önce bahsedilen resources. arsc dosyasına entegre edilir. Yani uygulama paketi çalıştırıldığında artık res/ klasöründeki orijinal dosyalar yerine resources. arsc içindeki derlenmiş veriler kullanılmaktadır. (Bu dizindeki XML’ler ve PNG’ler APK içinde sıkıştırılmış halde bulunur, ancak resources. arsc sayesinde hızlıca indekslenir. )</p><p><strong><em>assets/ Dizini</em></strong></p><p>Bu klasörde uygulama geliştiricisinin düzenlediği ham veri dosyaları yer alır. Örneğin, bir oyunun seviyelerini tanımlayan JSON dosyaları, bir font (. ttf) dosyası veya uygulamada gereksinim duyulan diğer temel veriler burada yer alabilir. assets klasöründeki dosyalar, uygulama çalıştığı sürede AssetManager kullanılarak erişilebilir. Bu dosyalara, herhangi bir derleme aşamasında kimlik ataması yapılmaz; yani R sınıfında bu dosyalar için herhangi bir kayıt yoktur. Geliştirici, dosyanın adını kullanarak bu içeriklere ulaşır (örneğin getAssets(). open(“config. json”) ile). assets altında bulunan dosyalar, sıkıştırılmamış hâlde paketlenir ve ihtiyaç duyulduğunda doğrudan diskten okunur. Ve ihtiyaç duyulduğunda doğrudan, sistemin sağladığı yüksek seviyeli işlevleri rahatlıkla kullanabilir.</p><p><strong><em>lib/ Dizini</em></strong></p><p>Uygulamanın içerdiği yerel kütüphaneler bu klasörde yer alır. Uygulama, C/C++ ile yazılmış düşük seviye kodlar ya da hazır kütüphaneler içeriyorsa, bunlar .so (paylaşılan nesne) dosyaları olarak lib/ klasöründe bulunur. Mobil cihazlarda farklı CPU mimarileri bulunduğu için, bu klasörde genellikle çeşitli alt klasörler yer alır (armeabi-v7a/, arm64-v8a/, x86/ gibi). Her bir alt klasör, o mimariye uygun olarak derlenmiş .so dosyalarını barındırır. Örneğin, 64-bit ARM bir cihazda çalışacak olan kod, arm64-v8a klasöründen temin edilir. Bu sayede uygulama, cihazın mimarisiyle uyumlu yerel kodları kullanma imkânına sahip olur. Eğer yanlış bir mimari için oluşturulmuş bir kütüphane yüklenirse, uygulama çalışırken UnsatisfiedLinkError hatasıyla karşılaşılabilir (örneğin bir ARM cihazda x86 için derlenen kütüphane olmadığı durumda). Bu nedenle geliştirici, desteklemek istediği tüm mimariler için .so dosyalarını derleyip APK’ya eklemelidir.</p><p>Not: Bu kütüphaneler, uygulamanın performans açısından önemli bölümlerinde (örneğin grafik işlemlerinde, video/ses codec’lerinde) önemli avantajlar sağlarken, APK boyutunu artırmaktadır, bu nedenle dengeli bir şekilde kullanılmaları gerekmektedir.</p><p><strong><em>META-INF/ Dizini</em></strong></p><p>Bu klasör, APK’nın imzası ve bütünlük kontrolü bilgilerini barındırmaktadır. Android uygulamaları, yayınlanmadan önce geliştiricisi tarafından dijital olarak imzalanmalıdır. Bu imzalama işlemi sonrasında APK içinde META-INF klasörü oluşur ve içinde MANIFEST. MF, CERT. RSA ve CERT. SF adında dosyalar bulunur. Kısacası, bu dosyalar APK içindeki dosyaların hash değerlerini ve imza sertifikasını içermektedir. Cihazınıza bir APK yüklerken, sistem bu klasördeki bilgileri kullanarak paketin bütünlüğünü onaylar ve geliştiricinin kimliğini doğrular. Örneğin, APK indirilirken içerik değiştirilmiş mi ya da benzer bir uygulama yüklemeye çalışan başkası mı var, bu imza kontrolü ile anlaşılır. İmzada bir sıkıntı oluşursa yükleme durdurulur (“Uygulama yüklenemedi, paket bozulmuş veya imza geçersiz” hatası). Bu nedenle META-INF klasörü, güvenlik açısından oldukça önemlidir.</p><p>Yukarıda belirtilen bileşenler bir araya gelerek APK dosyasını meydana getirir (şemadaki ağaç yapısına dönerek, burada tüm bu dosyaların bir araya getirildiğini görebilirsiniz). Kısaca özetlemek gerekirse, APK = ZIP arşivinde kod (classes. dex), manifest, kaynaklar (res/ + resources. arsc), varsa yerel kütüphaneler (lib/) ve imza bilgileri (META-INF/) bulunan bir pakettir. Android işletim sistemi, bir APK’yı yükleyip çalıştırırken bu bileşenlerin her birini uygun şekilde kullanır.</p><p>Serinin bir sonraki yazısında<strong>,</strong> bu statik dosyayı dinamik bir sürece yaklaştıran en kritik adımı, yani Derleme Süreci’ni ve Android’in kalbindeki sanal makine olan Android Runtime (ART) ile DEX Bayt Kodu mimarisini derinlemesine inceleyeceğiz.</p><p><a href="https://medium.com/@yunuscakici.08/bir-apk-nas%C4%B1l-%C3%A7al%C4%B1%C5%9F%C4%B1r-8edb1d614ebb"><strong>Part 2 — Kaynak Kodu APK’ya Nasıl Dönüşür? (Derleme, DEX ve ART)</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a70f39dd4c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ANDROID SİSTEM MİMARİSİ]]></title>
            <link>https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-10755e3ba51c?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/10755e3ba51c</guid>
            <category><![CDATA[android-apps]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sun, 12 Oct 2025 14:27:25 GMT</pubDate>
            <atom:updated>2025-10-12T14:48:10.123Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Sistem Mimarisi: Katmanlara Yolculuk</h3><p>PART 3 — Yönetim ve Kullanıcı Arayüzü</p><p>Bu blog serimizde Android işletim sisteminin mimari katmanlarını birlikte gözden geçiriyoruz. Anlatımımız sırasında Linux Kernel, Donanım Soyutlama Katmanı (HAL), Android Runtime (ART), Yerel (Native) Kütüphaneler, Java API Çerçevesi ve Sistem Servislerini tek tek inceliyoruz. Ayrıca en üstteki Uygulama Katmanı ile katmanlar arasındaki ilişkiler hakkında da bilgi vererek gerçek hayattan örneklerle konuyu daha anlaşılır hale getiriyoruz. Bu serinin ilk yazısı olan Temel ve Donanım yazısına <a href="https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-e6cadfdb2ff3">buradan</a> ve ikinci yazısı olan Çalışma Ortamı ve Hız yazısına da <a href="https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-b068f550e104">buradan</a> erişebilirsiniz. Bu serinin üçüncü ve son yazısı olan <strong>Yönetim ve Kullanıcı Arayüzü</strong>’nde, Android operasyonlarının merkezi koordinasyonunu sağlayan <strong>Sistem Servislerine</strong>, geliştiriciler için soyutlanmış arayüzleri sunan <strong>Java API Framework</strong>’e ve tüm bu mimarinin son çıktısı olan <strong>Uygulama Katmanı</strong>’na değiniyor olacağız.</p><blockquote><strong>Java API Framework Katmanı</strong></blockquote><p>Android’in en üst düzeyinde, uygulama geliştiricilerin doğrudan etkileşimde bulunduğu Java API Çerçeve katmanı yer almaktadır. Bu katman, Android SDK içerisinde yer alan tüm yüksek seviyeli API’leri içerir; bu API’ler uygulamaların kullanıcı arayüzü oluşturmasından, cihaz donanımını kullanabilmesine kadar pek çok şeyi sağlayan sınıf ve hizmetleri kapsar. Çerçeve katmanı, Android işletim sistemi ile uygulama geliştiricileri arasında bir tür soyutlama sağlar. Bu sayede bir geliştirici, altta neler olduğuna dair (donanımın nasıl çalıştığı, verilerin nasıl saklandığı gibi) derinlemesine bilgiye sahip olmadan, sistemin sağladığı yüksek seviyeli işlevleri rahatlıkla kullanabilir.</p><p>Bu katmanda ne tür bileşenler mevcut? Ana bileşenler şunlardır:</p><ul><li><strong>Uygulama Bileşenleri için Temel Sınıflar:</strong> Android uygulamaları, bildiğiniz üzere Activity, Service, BroadcastReceiver ve ContentProvider gibi öğelerden oluşmaktadır. Bu bileşenlerin temel sınıfları (Activity, Service vb. ) Çerçeve katmanında tanımlanmıştır. Örneğin bir Activity (ekran) oluşturmak istediğinizde Activity sınıfını genişletirsiniz; bu sınıf Android işletim sistemi tarafından yönetilen bir yaşam döngüsüne sahiptir (onCreate, onStart, onResume, onPause, onStop, onDestroy gibi fonksiyonlar). Bu mekanizmalar, Çerçeve katmanındaki kod ile sağlanır — geliştirici sadece uygulamanızın belirli noktalarında neler yapması gerektiğini yazar ve altyapıyı Android yönetir. Benzer şekilde, Service, arka planda çalışan bir işlem için bir yapı sağlar ve sistem tarafından denetlenir. Kısacası Çerçeve, uygulama bileşenlerinin davranışlarını tanımlayan bir altyapı sunar.</li><li><strong>Kullanıcı Arayüzü ve Widget Kütüphaneleri:</strong> Android, zengin bir UI kütüphanesine sahiptir — butonlar, metin kutuları, listeler vb. ekran arayüzleri View ve ViewGroup hiyerarşisi sayesinde oluşturulmaktadır. Bu kullanıcı arayüzü bileşenleri Çerçeve katmanının bir parçasıdır. Örneğin, Button ya da TextView gibi sınıflar bu katmanda tanımlıdır ve bunların nasıl görüntüleneceği ve nasıl davranacağı burada yer alan kod tarafından belirlenir. Geliştirici XML ile bir arayüz tasarladığında ya da kodla bir buton oluşturduğunda, aslında Çerçeve’de tanımlı bu sınıfları kullanmış olur. Bu katman, dokunmatik ekran etkileşimlerini de yönetir: Bir View’a dokunduğunuzda meydana gelen onClick gibi olaylar, yine Çerçeve içerisindeki kod ile sağlanır. Yüksek seviyede her şey basit ve tutarlı görünmektedir — örneğin, tüm butonların tıklanma mantığı aynıdır — çünkü altındaki uygulama tek bir yerde, Çerçeve’de tanımlıdır.</li><li><strong>Yönetici Sınıfları (Managers) ve Hizmet Arayüzleri:</strong> Android Framework, sistem servislerinin fonksiyonlarını uygulamalara sunan Manager adında sınıflar içerir. Bu sınıflar genellikle belirli bir sistem hizmetine karşılık gelir. Örneğin, konum hizmetine erişmek için LocationManager; bildirim servisine erişim için NotificationManager; cihaz sensörlerine erişmek için SensorManager kullanılır. Bu manager sınıfları, uygulama ile system\_server içinde çalışan ilgili sistem servisi arasında bir köprü görevi üstlenir. Her Manager sınıfının arkasında genellikle bir Binder arayüzü bulunur. Bu durumda, uygulama tarafında LocationManager. getLastKnownLocation() gibi bir metot çağrıldığında, bu metod aslında yalnızca bir Binder isteği hazırlayıp çekirdek üzerinden ilgili servise (LocationService) yollar. ServiceManager, gerekli servisi bulur ve ona bağlanır. Gerçek işlem ise konum servisi tarafından gerçekleştirilir ve sonuç yine binder aracılığıyla geri gelir. Özetle, Manager sınıfları istemci tarafında çalışan ve sistem servislerine aracılık eden (proxy) sınıflardır. Bu tasarım sayesinde uygulamalar, yerel bir nesne gibi basit bir API kullanırken, gerçekte işletim sistemi çekirdek servislerine erişim sağlarlar. Örneğin, NotificationManager. notify() metodu çağrıldığında, uygulamanız aslında NotificationManagerService’e “şu bildirimi göster” isteğini iletir; servis de bildirimi üst çubukta gösterir.</li><li><strong>İzin Sisteminin Arayüzü:</strong> Android Framework, uygulamaların güvenlik izinlerini denetlemek için de sorumluluk alır. Örneğin, bir uygulama LocationManager üzerinden konum almak istediğinde, Framework katmanı önce bu uygulamaya KONUM izni tanınıp tanınmadığını kontrol eder. Bu kontrol, uygulamanın manifestinde belirtilen izinler ile kullanıcıdan alınan onaylarla gerçekleştirilir. Eğer izin verilmemişse, Framework katmanı isteği reddedebilir veya bir hata dönebilir. Bu sayede uygulama geliştiricisinin ekstra bir işlem yapmasına gerek kalmadan, sistem otomatik olarak hassas API çağrılarının denetimini yapar. (Tabii ki modern Android’de konum gibi tehlikeli izinler için kullanıcıya onay alma, izin verme/geri çekme dinamik bir hale getirildi; bu mekanizmalar bu katmanda işlenmektedir. )</li><li><strong>Diğer Yardımcı Hizmetler:</strong> Framework katmanı, uygulamaların işlerini kolaylaştıran birçok başka hizmet sunmaktadır. Örneğin, ContentProvider mekanizması (uygulamalar arası veri paylaşımı veya cihaz rehberi, medya gibi verilere erişim için) bu katmanda tanımlıdır. Eğer ContentResolver aracılığıyla rehberden bir kişiyi okumak isterseniz, arka planda o içeriğe erişim sağlayan ContentProvider’lara Framework istek gönderir. Benzer biçimde, Resource Manager uygulamanın dil veya ekran boyutu gibi farklı kaynak dosyalarını yüklemesine imkan tanır; View System ise pencere yönetimini ve ekrana çizimi düzenler (bu kısım WindowManagerService ile iç içe çalışır).</li></ul><p>Bu katmanın en dikkat çekici özelliği, geliştiricilere basit bir API sunarken arka plandaki karmaşayı gizlemektedir. Örneğin, telefonun titremesini sağlamak için uygulamanızda Vibrator. vibrate() fonksiyonunu çağırmanız yeterlidir. Bu talep, VibratorManager aracılığıyla sistemin ilgili servisine iletilir ve cihaz titreşmeye başlar. Burada bilmeniz gerekmeyen detay: Bu titreşim isteği aslında bir donanım çağrısıdır ve belki özel bir motoru etkin hale getirir, belki belirli bir süre veya dalga biçimini hesaplar. Tüm bu işlemler Android Frameworkü ve alttaki servis/HAL katmanları tarafından gerçekleştirilir. Geliştirici ise yalnızca bir satır kod yazarak amacına ulaşır.</p><p>Burada önemli bir nokta vardır: Framework katmanı ile Sistem Servisleri katmanı birlikte çalışmaktadır. Genellikle bahsettiğimiz Manager sınıfları, system\_server içindeki gerçek servislerle doğrudan ilişkilidir. Sistem Servisleri kısmında daha fazla detay vereceğiz ancak akılda kalması açısından birkaç örnek verelim: ActivityManager adında bir framework sınıfı mevcuttur ve bu sınıf, uygulamalara activity’leri (ekranları) yönetmek için metodlar sunar. Bunun sistem tarafındaki karşılığı ise ActivityManagerService (AMS) isimli bir servistir. ActivityManager üzerinden getRunningTasks() gibi bir metot çağırdığınızda, aslında AMS’ye bir binder mesajı gönderilir ve size AMS’den bir yanıt gelir. Benzer şekilde, PackageManager sınıfı uygulamalara yüklü paketleri sorgulama imkanı sunarken, bu işi yapan asıl servis PackageManagerService (PMS)dir; NotificationManager bildirimleri kaydeder fakat görüntüleme işlemlerini NotificationManagerService üstlenir; SensorManager sensörle ilgili verileri talep ederken, SensorService bu verileri sağlar; liste böyle devam eder. Yani Framework, istemci tarafı; Sistem Servisi ise sunucu tarafı olarak nitelendirilebilir. İki taraf arasındaki iletişim Binder aracılığıyla sağlanır. Bu mimari, işletim sisteminin modüler olmasını destekler; örneğin bir servis arızalanırsa ya da çökerse, uygulamanın kendisi bunun sonucunda etkilenmez sadece arka plandaki servis etkilenir (elbette o da hemen yeniden başlatılır). Uygulama, belki “hizmet şu anda mevcut değil” hatası alır ama doğrudan çökmez.</p><p>Sonuç olarak, Java API Framework katmanı, Android’in programlanabilir yüzünü temsil etmektedir. Uygulama geliştiricilerine zengin ve yüksek seviyeli araçlar sunarak, onların yazdığı kodu somut işlemlere dönüştürüp çalıştırır. Android’i diğer işletim sistemlerinden ayıran birçok yenilik (esnek arayüz tasarımı, kapsamlı kütüphane desteği, entegre özellikler ve benzeri) bu katmanda yer almaktadır.Şimdi, bu anlatılan framework API’lerinin arkasındaki kahramanlara, yani Sistem Servisleri’ne yakından bakalım.</p><p><strong>Sistem Servisleri</strong></p><p>Android işletim sistemi için temel işlevleri yerine getiren ve genellikle arka planda faaliyet gösteren uzun süreli bileşenlerdir. Bu bileşenler, Android cihazının akıllıca çalışmasını sağlayan yöneticilerdir: Uygulamaları başlatma ve durdurma, ekran görüntüleri oluşturma, çağrılar üzerinde yönetim gerçekleştirme ve bildirimleri gösterme gibi görevleri vardır. Kısacası, cihazın işletim sistemi ile ilgili davranışlarını kontrol eden öğelerdir. Sistem servisleri genellikle “SystemServer” adlı özel bir süreç içerisinde işlem görür; ancak bazı önemli servisler farklı süreçlerde de çalışabilir (örneğin, medya oynatımına ilişkin bazı servisler veya grafik kompozitörü kendi süreçlerinde çalışır).</p><p>SystemServer süreci, Android başlatıldığında aktif hale gelir ve birçok temel servisi bu tek süreç içinde oluşturup çalıştırır. Bu işlem, Android’in init sürecinin tamamlanmasının ardından Zygote üzerinden fork ile gerçekleştirilir: Cihaz açıldığında, kernel ve init süreci başladıktan sonra, Zygote işleminden bir fork ile SystemServer süreci oluşturulur. SystemServer, Java dilinde geliştirilmiştir ve ART üzerinde çalışmaktadır. SystemServer. java isimli bir sınıfın main() metodu ile başlar. Sonrasında sırasıyla çeşitli servisleri başlatır: Önce temel servisler (ActivityManager, PowerManager gibi), ardından diğer servisler sırayla devreye girer. Her bir servis başlangıçta kendisini ServiceManager olarak bilinen merkezi bir kayıt defterine kaydeder. Bu, diğer bileşenlerin o servise kolayca ulaşabilmesini sağlar (Binder aracılığıyla servisi adıyla bulabilirler).</p><p>Sistem servislerinin örneklerine göz atalım ve bu servislerin ne yaptığını inceleyelim:</p><ul><li><strong>ActivityManagerService (AMS): </strong>Uygulama döngüsünü kontrol eden en önemli servislerdendir. Bir uygulama başlatılacağı zaman AMS devreye girer, Zygote’a yeni bir süreç oluşturması için talimat verir, Activity’lerin onCreate gibi çağrılarını koordine eder. Uygulamalar arası geçişler, arka plana alma ve bellek tükenmesi durumunda uygulamaların kapatılması gibi politikaları AMS belirler. Özetle, telefonunuzda uygulamalar arasında geçiş yaptığınızda arka planda işlerin yürütülmesini sağlayan “uygulama trafik polisi” AMS’dir.</li><li><strong>WindowManagerService (WMS): </strong>Ekrandaki pencereleri kontrol eden servistir. Hangi pencerenin üstte olacağı, boyutlarının ne olacağı ve ekran döndüğünde neler olacağı gibi konular WMS’in sorumluluğundadır. Bir uygulama yeni bir Activity oluşturduğunda, bu süreçte AMS ile iş birliği yaparak pencereyi oluşturan WMS’dir. Ayrıca çoklu pencere desteği ve picture-in-picture gibi özellikler de WMS tarafından yönetilir. WMS, SurfaceFlinger ile de yakın işbirliği içinde çalışır; uygulama arayüzünden gelen görseller SurfaceFlinger’da birleştirilerek ekrana gönderilir ve WMS hangi uygulamanın ne zaman görüneceğini düzenler.</li><li><strong>PackageManagerService (PMS):</strong> Cihazda yüklü olan uygulamaların takibini gerçekleştiren servistir. Yeni bir APK yüklendiğinde (kullanıcı tarafından ya da sistem güncellemesi ile) bu servis devreye girer; APK’nın içindeki AndroidManifest. xml dosyasını inceleyerek uygulamanın bileşenleri, talep ettiği izinler ve kayıtlı paket adı gibi bilgileri toplar. Uygulamayı sisteme kaydeder (veritabanına yazar). Uygulama silindiğinde bu servis de kaydı kaldırır. Ayrıca uygulama sürüm bilgileri, imza doğrulama ve izin atama gibi işlemler de bu servis tarafından gerçekleştirilir. Uygulamalar kendi bilgilerini ya da diğer uygulamalar hakkında bilgi sorguladığında (örneğin, “Bu telefonda Facebook var mı? ” diye sorulduğunda) PMS devreye girer.</li><li><strong>NotificationManagerService:</strong> Bildirimleri durum çubuğunda gösteren, güncelleyen ve önceliklerini yöneten servistir. Bir uygulama NotificationManager üzerinden yeni bir bildirim yolladığında, istek NotificationManagerService’e aktarılır ve servis bildirimi kullanıcıya sunar. Bildirim tıklandığında ilgili uygulamayı bilgilendirir, sürüklenildiğinde kapatır vb.</li><li><strong>ConnectivityService:</strong> Wi-Fi, mobil veri, Bluetooth ve VPN gibi ağ bağlantılarını yöneten servistir. Arka planda radyo modüllerini kontrol eder, hangi ağın aktif olduğunu takip eder ve uygulamalara ağ durumu ile ilgili bilgi sağlar. Örneğin, Wi-Fi’ye bağlandığında bu servis devreye girer, IP alır, DNS ayarlarını yapar ve diğer uygulamalara “Wi-Fi bağlı” şeklinde bildirim yollar.</li><li><strong>PowerManagerService:</strong> Cihazın enerji yönetimini sağlayan servistir. Ekranın ne zaman kararması, uyku modunun ne zaman aktif olacağı ve cihazın sürekli açık kalmasını sağlamak için yapılan wake lock taleplerini yönetir. Örneğin, bir video izlerken ekranın kapanmaması bu servis sayesinde gerçekleşir (medya uygulaması wake lock alır, PowerManagerService ekranı açık tutar). Aynı zamanda batarya durumu, şarj durumu gibi bilgileri izler ve kritik durumlarda (örneğin, batarya düşükse) sistemi bilgilendirir.</li><li><strong>AlarmManagerService:</strong> Android işletim sisteminde zamanlanmış görevlerin belirlenmesine yardımcı olur. Uygulamalar, belirli bir tarih veya düzenli aralıklarla çalışması için AlarmManager aracılığıyla sistemden taleplerde bulunurlar. Bu talepleri toplayıp uygun zaman geldiğinde ilgili uygulamaları aktif hale getiren AlarmManagerService’dir. Örneğin, sabah saat 9’da bildirim göndermek isteyen bir uygulamaya, sistem bu hizmet yardımıyla onay verir ve tam zamanında uygulamayı harekete geçirir.</li><li><strong>TelephonyRegistry / Telefon Hizmetleri:</strong> Cihazın telefon görüşmesi, SIM kart ve operatör sinyali gibi iletişim bilgilerini yöneten hizmetler bulunmaktadır. Bu hizmetler, modem veya çip setiyle iletişim kurarak (genellikle alt seviyede ayrı bir radyo işlemcisi barındırır) gelen aramaları yönetir, SMS gönderimini gerçekleştirir, sinyal gücünü gözlemler, uçak modunu açar veya kapatır gibi işlevler görür.</li></ul><p>Elbette sistem hizmetleri bunlarla sınırlı değildir — Android’de birçok sistem hizmeti mevcuttur (Android’in tam listesi ServiceManager üzerinden kayıtlı hizmet adları olarak gözlemlenebilir). Örneğin, InputMethodManagerService (klavye girişleri ve IME’leri yöneten hizmet), DevicePolicyManagerService (kurumsal cihaz yönetimini gerçekleştiren hizmet), ClipboardService, UsbService ve SoundTriggerService (sesle etkinleştirme “OK Google” vb. ) gibi özel birçok hizmet bulunmaktadır. Hatta üretici firmalar kendi gereksinimlerine göre sisteme yeni hizmetler ekleyebilirler (örneğin, Samsung cihazlarda SmartManagerService gibi veya özel güç yönetimi hizmetleri). Android’in modüler yapısı sayesinde ServiceManager’a kaydedilen her bir hizmet, uygulamalar tarafından erişilebilir hale gelir.</p><p>Şimdi sistem hizmetlerinin nasıl çalıştığına ve framework ile olan ilişkisine bir göz atalım. Öncelikle, Framework kısmında bir uygulamanın API çağrısının Binder aracılığıyla sistem hizmetine ulaştığını ifade etmiştik. Bunu bir örnek akış senaryosu ile açıklamak, durumu daha net ortaya koyacaktır:</p><p>Örnek Senaryo: Bir Activity başlatma süreci (yeni bir uygulama ekranı açılması):</p><ul><li><strong>Uygulama üzerinden yapılan çağrı:</strong> Kullanıcı, uygulaması aracılığıyla bir activity başlatmak için bir niyet bildirimi oluşturur veya yeni bir ekran açılır. Uygulamanın kodu, Framework’teki uygun metoda, örneğin startActivity() yöntemine çağrı yapar. Bu çağrı, ActivityManager üzerinden bir binder isteği hazırlayarak ActivityManagerService’e iletilir.</li><li><strong>Binder IPC:</strong> ActivityManager sınıfı, içinde bir Binder proxy barındırdığı için, startActivity gibi bir yöntem çağrıldığında, bu mesaj binder sürücüsü aracılığıyla SystemSever’daki AMS’ye ulaşır. Kernel, binder mesajını gönderirken uygulamanın UID bilgilerini de ekler, böylece AMS bu isteğin hangi uygulamadan geldiğini tespit edebilir.</li><li><strong>Sistem Servisinin işlemi yerine getirmesi:</strong> ActivityManagerService, binder üzerinden gelen isteği alır ve yeni bir activity başlatma isteğini inceler. Bu işlem birkaç alt adımdan oluşur: İlk olarak, isteği gönderen uygulamanın gerekli izne sahip olup olmadığı (özellikle farklı bir uygulama başlatmak isteniyorsa) kontrol edilir. Daha sonra, yeni activity’nin ait olduğu uygulamanın çalışır durumda bir sürecinin olup olmadığına bakılır. Eğer uygulama bellekte yoksa, Zygote’a talimat vererek yeni bir uygulama süreci başlatılır. Ardından, bu süreç içerisinde ilgili activity oluşturulur ve onCreate gibi yaşam döngüsü yöntemlerinin çağrılması sağlanır. Activity’nin oluşturduğu pencere bilgisi WindowManagerService’e aktarılır, böylece arayüz çizilebilir hale gelir. Bu aşamada AMS, farklı sistem servisleriyle (PackageManagerService, WindowManagerService vb. ) uyumlu bir şekilde çalışır. Örneğin, eğer uygulama yoksa Zygote ile yeni süreç fork etmek için Process adlı yardımcı birimi kullanır, pencereyi hazırlamak için WMS’yi çağırır, vb.</li><li><strong>Sonucun döndürülmesi:</strong> Activity başarılı bir şekilde başlatıldığında AMS, binder aracılığıyla uygulamaya bir yanıt gönderir; bu genellikle “işlem tamam” anlamına gelen bir durum bilgisidir. Uygulamadaki startActivity() çağrısı da normal seyrine devam eder (çoğu zaman bu yöntem asenkron çalıştığı için kullanıcı bu detayları fark etmez). Bir hata meydana gelirse (örneğin ilgili Activity bulunamazsa) AMS binder ile bir hata kodu veya istisna döner ve uygulama bunu yakalar.</li><li><strong>Ekranın gösterimi:</strong> Bu süreçte WindowManagerService ve SurfaceFlinger iş birliğiyle yeni Activity’nin arayüzü kullanıcıya sunulur. Uygulamanın onResume() yöntemi çalışır ve kullanıcı artık yeni ekranla etkileşimde bulunabilir. Tüm bu işlemler genellikle çok kısa bir sürede gerçekleşir.</li></ul><p>Bu senaryo, sistem servisleri ile framework’ün nasıl birlikte çalıştığını gösteren bir örnektir. Benzer süreçler, başka işlemler için de geçerli olabilir: Örneğin, bir bildirim gösterme süreci de.</p><p>NotificationManager, NotificationManagerService’e benzer bir şekilde hareket eder; telefon araması alındığında RIL (Radyo Arayüz Katmanı) üzerinden bir hizmet devreye girer, telefonu çaldırır ve Telephony servisi arayüzü bilgilendirir; SMS alındığında ise bir yayınla ilgili uygulamalara bilgi iletilir. Bu durumların hepsinin ortak özelliği, sistem hizmetlerinin merkezi işlevleri olmasıdır.</p><p>Birden fazla servis aynı işlem (SystemServer) içerisinde çalıştığı için aralarındaki iletişim hızlıdır; çünkü aynı bellek alanını paylaştıkları için binder olmadan doğrudan çağrılar yapabilirler. Örneğin, uygulama başlatacak olan AMS, WMS’yi çağırdığında, aslında bu işlem içinde bulunduklarından dolayı fonksiyon çağrısını hızlıca gerçekleştirir. Bu durum hem performans hem de entegrasyon açısından faydalıdır. Ancak, SystemServer çökmüşse pek çok önemli hizmet aynı anda yok olacağı için tüm sistem bundan etkilenir; bu da cihazın donup yeniden başlatılmasına yol açabilir. Bu sebeple Android, SystemServer’ı korumak için büyük önlemler alır; düşük seviyeli SELinux politikaları bu süreçte özel kısıtlamalar getirir ve her servis çağrısında parametre kontrolleri uygulanır. Ayrıca, SystemServer ‘ın yetkileri sınırlıdır; root erişimi yoktur; bu nedenle sadece özel bir sistem kullanıcısı ile ve gerekli izinlerle çalışır. Böylece bir saldırgan SystemServer’a müdahale etse bile, yapabileceği şeyler kısıtlanmış olur; örneğin, kritik dosyalara doğrudan ulaşamaz. Android’in güvenlik yapısında, SystemServer önemli süreçlerden biri olarak “yüksek ayrıcalıklı ama kontrol altında” bir pozisyona sahiptir.</p><p>Sonuç olarak, Sistem Servisleri Android’in temel yapı taşlarıdır. Kullanıcı tarafından doğrudan görülmezler ancak cihazın tüm eylemlerinde rol oynarlar. Uygulamaların düzgün çalışmasını sağlayan, kaynakları yöneten ve donanımın koordinasyonunu gerçekleştiren bu servisler olmasaydı, Android yalnızca basit bir çekirdek ve birkaç kütüphane ile sınırlı kalırdı; arada orkestrayı yöneten bir şefe ihtiyaç vardır ve bu rolü sistem servisleri üstlenir.</p><p>Bu noktaya kadar Android’in ana mimari katmanlarını gözden geçirdik: Kernel, HAL, Runtime, Yerel Kütüphaneler, Framework ve Sistem Servisleri. Bu katmanlar, uygulamalara altyapı sunarak birlikte işlev görür. Şimdi en üst katman olan Uygulamalar katmanına odaklanarak genel resmi tamamlayalım.</p><blockquote><strong>Uygulama Katmanı</strong></blockquote><p>En üst düzeyde, kullanıcı ve sistem uygulamalarının yer aldığı bir katman bulunmaktadır. Bu uygulamalar, mimari yapının bir parçası olmasalar da, Android mimari diyagramlarında genellikle en üstte “Uygulamalar” katmanı olarak gösterilmektedir. Bu katmanda, Google Play’den indirdiğimiz ya da cihazla birlikte yüklü gelen uygulamalar bulunur: Örneğin sosyal medya uygulamaları, oyunlar, rehber, mesajlaşma uygulamaları ve kamera uygulamaları gibi.</p><p>Uygulama katmanı, doğrudan son kullanıcı ile etkileşime giren yazılımlar içerir. Bu uygulamalar, kendilerinin farkında olmadan, altındaki tüm katmanlardan gelen hizmetlerden yararlanırlar. Örneğin, bir yemek siparişi uygulaması harita üzerinden konum gösterdiğinde, arka planda Konum Servisi (GPS verisi için) ve Google Maps API (harita verisi için) aktif durumda olabilir. Bir müzik uygulaması müzik çalarken, MediaPlayer API aracılığıyla AudioFlinger ve ilgili HAL’ler çalışmaktadır. Kullanıcı uygulamaları, Android’in sağladığı tüm framework API setini kullanarak hizmet alır ve böylece telefonun donanım öğelerine (kamera, mikrofon, sensörler), sistem servislerine (bildirim, konum vs. ) ve internet gibi dış kaynaklara kolaylıkla erişirler.</p><p>Android, her bir uygulamayı sistemde farklı bir kullanıcı (UID) ile çalıştırarak ve her birine ayrı bir sanal makine (ART) süreci atayarak uygulama katmanını izole etmektedir. Bu yaklaşım güvenliğin temel ilkelerindendir: Bir uygulamanın yaşadığı sorunlar veya çöküşler diğer uygulamaları direkt olarak etkilemez; her uygulama kendi verilerine erişebilir fakat başka bir uygulamanın verilerine (paylaşılmadığı sürece) ulaşamaz. Uygulamalar arası iletişim, yalnızca belirlenen yollarla (örn. Intent mekanizması veya ContentProvider paylaşımı) sağlanır ve bu yöntemler izin kontrolüne tabidir.</p><p>Sistem uygulamaları da uygulama katmanının bir parçasını oluşturur — örneğin telefon arama uygulaması, SMS uygulaması ve ayarlar uygulaması gibi temel programlar, aslında Android’in bir parçasıdır, fakat kendi mimari yapılarına göre üçüncü parti uygulamalarla aynı ortamda çalışmaktadırlar (genellikle tek farkları daha yüksek izinlere sahip olmalarıdır). Örneğin “Ayarlar” uygulaması, özel sistem API’larını kullanma yetkisine sahiptir çünkü sistem imzası ile onaylanmıştır ve bu nedenle normal uygulamaların yapamayacağı bazı işlemler (parlaklığı değiştirmek gibi) gerçekleştirebilir. Ancak teknik açıdan bu da bir uygulama olarak kabul edilir, Activity’leri ve servisleri olan bir APK’dır.</p><p>Uygulama katmanını, gerçek hayattaki ürünler gibi düşünebiliriz. Altındaki tüm mimari katmanlar (temelden çatıya kadar) bu uygulamaların etkin, hızlı ve güvenli bir şekilde çalışabilmesi için inşa edilmiştir. Kullanıcı, örneğin bir oyun oynarken, bu oyunun grafiklerini oluşturan OpenGL kütüphanesini, seslerini çalan AudioTrack API’sini, internet üzerinden veri çeken OkHttp kütüphanesini ve konum hizmetlerini kullanıyor olabilir ama bunların farkında olmayabilir — sadece oyunun tadını çıkarır. Ancak mühendisler için bilinmesi gereken, bu rahatlığın arkasındaki yapısal katmanların birbiriyle uyumlu bir şekilde işlediğidir.</p><p>Son kullanıcının bakış açısına göre: Android’de uygulamalar yüklenir, çalıştırılır, kullanıcı arayüzü sağlar ve işlemlerini gerçekleştirir. Her uygulama gerekli alt katmanları kullanır. Bazı uygulamalar hiç donanım gerektirmez (örneğin basit bir not uygulaması), bazıları ise yoğun bir şekilde sensörler ve grafik işleme birimi kullanır (örneğin artırılmış gerçeklik navigasyon uygulamaları). Android’in katmanlı yapısı sayesinde, her türlü uygulama, ihtiyacına uygun API’leri bulabilir. Geliştirici ise yalnızca bu API’leri öğrenip kullanmaya odaklanır — alt katmanda hangi donanımın bulunduğu veya sistemin iç işleyişiyle çok fazla ilgilenmez. Ancak geliştirici perspektifinden bakıldığında, Android mimarisini anlamak hala önemlidir. Çünkü hangi işlemlerin ne kadar maliyetli olduğunu bilmek, dikkat edilmesi gereken şeyleri belirlemek, uygulamaların daha etkin bir şekilde yazılmasını sağlar. Örneğin, UI işlemlerini daima ana iş parçacığında gerçekleştirmemiz gerektiğini unutmamalıyız; aksi takdirde “uygulama yanıt vermiyor” (ANR) mesajıyla karşılaşabiliriz — bu bilgi, mimarinin nasıl çalıştığını anlamaktan gelir.</p><p>Artık Android’in tüm katmanlarını ayrı ayrı inceledik. Şimdi genel bir değerlendirme yaparak, bu parçaların birlikte nasıl işlev gösterdiğini bir kez daha vurgulayalım.</p><blockquote><strong>Sonuç ve Genel Akış Özeti</strong></blockquote><p>Android’in yapısı, etkili bir iş bölümü ve soyutlama örneğidir. Linux Kernel katmanı, donanım kontrolünü sağlar ve güvenlik ile temel kaynak yönetimini üstlenir. HAL katmanı, cihaz üreticilerine donanım özelliklerini Android sistemine standart bir arayüzle sunma olanağı verir; böylece üst katmanlar donanım detaylarıyla uğraşmadan çalışabilir. Android Runtime (ART) ve Native Kütüphaneler, uygulamaların çalıştığı ortamı ve yüksek performansla işlemleri gerçekleştirmeyi sağlar; ART uygulama kodunu yürütürken Native kütüphaneler en önemli işlevleri hızlandırır. Java API Çerçevesi, uygulama geliştiricilerine zengin ve kolay kullanılan bir arayüz sunar; alt katmanların karmaşıklığını gizler. Sistem Hizmetleri, cihazın yönetim merkezi olarak her şeyi düzenler ve koordine eder. En üst sıradaki Uygulamalar ise bu orkestradan yararlanarak son kullanıcıya işlevsellik sunar.</p><p>Bu katmanlar arasındaki iletişim belirli yollarla sağlanır: Uygulama ile framework arasındaki fonksiyon çağrıları (metotlar), framework ile sistem hizmetleri arasındaki iletişim genellikle Binder IPC ile olur, sistem hizmetleri ile HAL arasındaki iletişim de yine binder veya doğrudan çağrılarla gerçekleşir. HAL ile kernel arasındaki iletişim ise sürücü çağrılarıyla sağlanır ve son olarak kernel ile donanım arasındaki bağlantı elektrik sinyalleri ve protokollerle gerçekleşir. Yani bir uçtan uca senaryoda, örneğin kullanıcı kamerayla fotoğraf çekmek için butona bastığında şunlar olur:</p><ul><li>Kamera uygulaması (uygulama katmanı) kullanıcı girişini UI’dan alır ve Framework’teki Camera API’ına çağrı yapar.</li><li>Framework, CameraService’e (sistem hizmeti) “fotoğraf çek” şeklinde bir binder mesajı gönderir.</li><li>CameraService, gerekirse kamera donanımını 활성leştirmek için HAL’i kullanır (HAL katmanı).</li><li>HAL, kamera sürücüsü aracılığıyla lensi kontrol eder ve sensörden görüntü verisini alır (kernel katmanı).</li><li>Yakalanan görüntü verisi, belki Native kütüphanelerden libjpeg kullanılarak JPEG formatında sıkıştırılır (native libraries katmanı).</li><li>Sonuç olarak fotoğraf dosyası oluşur; bu dosya uygulamaya geri gönderilir veya medya galeriye kaydedilir.</li></ul><p>Tüm bu işlemler milisaniyeler içerisinde sıralı bir şekilde gerçekleşirken, kullanıcı yalnızca bir deklanşör sesi duyar ve ekranda çektiği fotoğrafı görür.</p><p>Bu akışta hataların önlenmesi amacıyla her katmanda kontroller mevcuttur: Uygulamanın kamera izni yoksa framework aşamasında istek reddedilir; donanım meşgulse servis sıraya alır; HAL yanıt vermezse timeout mekanizmaları devreye girer vb. Yani sistem, ortaya çıkabilecek her durumu yönetmek üzere tasarlanmıştır. Android’in gücü, katmanlar arasındaki bu uyumlu iş birliğinden kaynaklanır.</p><p>Özetle, Android mimarisi sayesinde:</p><ul><li>Geliştiriciler karmaşık donanım ve sistem detaylarını düşünmeden uygulama geliştirebilirler (Soyutlama).</li><li>Sistem, farklı donanım platformlarında çalışabilir ve üretici uyarlamaları belirli bir sınır dahilinde tutulur (HAL/Kernel yapısı).</li><li>Güvenlik, katmanlı bir yapı aracılığıyla sağlanır: Uygulama seviyesindeki izinler, framework seviyesindeki kontroller ve çekirdek seviyesindeki izolasyon birlikte işlev gösterir.</li><li>Performans açısından önemli işlemler daha alt seviyelere yönlendirilerek kullanıcılara kesintisiz bir deneyim sunulur.</li><li>Yeni teknolojiler mimariye entegre edilebilir: Örneğin, yapay zeka hızlandırma, yeni bir yerel kütüphane ve HAL ile mimariye eklenerek framework üzerinden bir API haline getirilebilir (NNAPI örneğinde olduğu gibi).</li><li>Bakım ve güncellemeler daha kolay hale gelir: Katmanlı yapı, belirli bir bileşeni güncellerken diğer bileşenlere dokunmamayı sağlar (örneğin, Android 13’te birçok sistem hizmeti geliştirilirken, uygulama API seviyesi için geriye dönük uyumluluk bozulmaz).</li></ul><p>Sonuç olarak, Android işletim sistemi yapısı, mobil cihazların sınırlı kaynaklarını etkili bir şekilde kullanan, güvenliği öncelikli hedef olarak gören ve geliştiricilerin verimliliğini artıran bir sistemdir. Bu katmanların her biri, kendi sorumluluklarını en iyi biçimde yerine getirirken, bir üst ya da alt katmana belirgin arayüzlerle bağlı bulunmaktadır. Aralarında net bir şekilde belirlenmiş sınırlar olsa da, birlikte işlev gördüklerinde tek bir bütün gibi uyumlu bir sistem oluştururlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*ymoS4ZDQowY4X9WKHN7Z7g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10755e3ba51c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ANDROID SİSTEM MİMARİSİ]]></title>
            <link>https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-b068f550e104?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/b068f550e104</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android-apps]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-development]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sun, 12 Oct 2025 14:13:59 GMT</pubDate>
            <atom:updated>2025-10-12T14:49:26.232Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Sistem Mimarisi: Katmanlara Yolculuk</h3><p>PART 2 — Çalışma Ortamı ve Hız</p><p>Bu blog serimizde Android işletim sisteminin mimari katmanlarını birlikte gözden geçiriyoruz. Anlatımımız sırasında Linux Kernel, Donanım Soyutlama Katmanı (HAL), Android Runtime (ART), Yerel (Native) Kütüphaneler, Java API Çerçevesi ve Sistem Servislerini tek tek inceliyoruz. Ayrıca en üstteki Uygulama Katmanı ile katmanlar arasındaki ilişkiler hakkında da bilgi vererek gerçek hayattan örneklerle konuyu daha anlaşılır hale getiriyoruz. Bu serinin ilk yazısı olan Temel ve Donanım yazısına <a href="https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-e6cadfdb2ff3">buradan</a> erişebilirsiniz. Bu serinin ikinci yazısı olan <strong>Çalışma Ortamı ve Hız</strong>’da, Android uygulamalarının yüksek performansla çalışmasını sağlayan <strong>Android Runtime (ART)</strong> katmanına ve sistemin kritik görevlerini verimli bir şekilde yerine getiren <strong>Yerel Kütüphanelere</strong> değiniyor olacağız.</p><blockquote><strong>Android Runtime (ART) Katmanı</strong></blockquote><p>Android işletim sistemine bağlı uygulamalar ve bazı sistem hizmetleri, Android Runtime (ART) olarak adlandırılan bir çalışma ortamında faaliyet göstermektedir. ART, Android 5. 0 (Lollipop) sürümüyle birlikte Android’in standart çalışma zamanı haline gelmiştir; daha önceki sürümlerde Dalvik adlı bir sanal makine kullanılmaktaydı. Kısaca, ART ve Dalvik, Android’in Java ile yazılmış programların çalışma biçimidir. Bu katman, Android uygulamalarının yönetilen bir ortamda güvenli ve etkili bir şekilde çalışması için gerekli koşulları sağlar.</p><p>ART’nin ana işlevi, geliştiricilerin Java veya Kotlin benzeri dillerde yazdığı uygulama kodunu, cihazda çalışan makine koduna dönüştürerek yürütmektir. Uygulamalar, . dex uzantılı bayt kodu dosyaları halinde paketlenmektedir (Dalvik EXecutable formatı). Android Runtime, bu bayt kodunu alarak çalıştırır. Bunu gerçekleştirirken bir dizi iyileştirme ve sistem hizmeti sağlar:</p><ul><li><strong>Just-In-Time (JIT) ve Ahead-Of-Time (AOT) Derleme:</strong> Dalvik döneminde yalnızca JIT (eş anlık derleme) kullanılıyordu, fakat ART ile birlikte AOT derleme fikri getirildi. Android uygulamaları yüklendiğinde, ART bu uygulamaların bayt kodu ile cihazın işlemcisine uygun makine kodunu önceden derleyebilmektedir. Bu işlem “dex2oat” adlı bir araç aracılığıyla yapılmakta ve elde edilen ikili kod, cihazın hafızasında saklanmaktadır. Sonuç olarak, uygulama çalışırken yorum yapmaya gerek kalmadığı için doğrudan makine kodu çalıştırıldığı için performans artışı sağlanır. Bu AOT derleme, özellikle Lollipop döneminde önemliydi; ancak her uygulamanın yükleme sürecinde derlenmesi, ilk açılış süresinin uzamasına neden oluyordu (uygulama yüklenirken “uygulanıyor” ekranını görmemizin sebebi buydu). Ardından gelen Android sürümlerinde Google, JIT derlemeyi yeniden hayata geçirdi ancak bu sefer daha akıllı bir yöntemle: Profil temelli optimizasyon. Yani uygulama ilk kez çalıştırıldığında veya cihaz şarjdayken ART, uygulamanın en çok kullanılan kısımlarını JIT ile derler ve bir profil oluşturur; ardından bu kritik kısımları arka planda kalıcı olarak AOT derlemeye alır. Böylece uygulamalar hızlı bir şekilde açılır (ilk anda her şey derlenmediği için) ve zamanla performansları artar (sık kullanılan kodlar makine diline çevrilip optimize edilir).</li><li><strong>Çöp Toplama (Garbage Collection):</strong> ART, Java dilinin otomatik bellek yönetimi yeteneğini sunar. Uygulamalar bellek ayırırken (new ile nesne oluşturma) bu nesnelerin ne zaman serbest bırakılacağıyla ilgili düşünmezler; ART, arka planda bir çöp toplayıcı çalıştırarak kullanılmayan nesnelerin bellek alanını temizler. Android Runtime, mobil cihazlar için optimize edilmiş modern çöp toplama algoritmaları kullanır (örneğin, kuşaklı çöp toplama – nesneleri ömürlerine göre ayıran bir sistem, ya da eş zamanlı çöp toplama – uygulama ile aynı anda çalışan bir toplayıcı). Buradaki amaç, uygulamalardaki duraklamaları en aza indirmek ve bellek sızıntılarını engellemektir. Örneğin, bir oyun uygulaması çalışırken, ART&#39;nin çöp toplayıcısı belirli aralıklarla devreye girip atıl nesneleri temizler; bunu yaparken oyunda anlamlı bir takılma olmaması adına mümkün olduğunca hızlı ve arka planda gerçekleştirir.</li><li><strong>Core Libraries (Temel Kütüphaneler):</strong> ART ayrıca Android’in Java API’larının çoğunu sağlayan temel kütüphaneleri de kapsar. Java’nın standart kütüphanelerinin (koleksiyonlar, G/Ç, regex vb. ) Android&#39;e uyarlanmış versiyonları ve Android’e özgü kütüphaneler (örneğin grafik arayüz kütüphanesi) bu çalışma zamanı ile birlikte sunulmaktadır. Uygulamalar, bu zengin kütüphane setini kullanarak farkındalıklarını gerçekleştirir. Bu kütüphanelerin büyük bir bölümü Java dilinde geliştirilmiş olsa da, alt katmanda kritik bileşenler yerel (native) kod ile desteklenmektedir – buna çok yakında Native Libraries katmanında değineceğiz.</li></ul><p>ART&#39;nin başka bir önemli işlevi, uygulama süreçlerinin geliştirilmesi ve yönetimi ile ilgilidir. Android&#39;de yeni bir uygulama açılmak istendiğinde, sistem tamamen yeni bir sanal makine kurmak yerine Zygote adındaki bir mekanizmadan faydalanır. Zygote, Android başlatıldığında çalışan ve içinde ART ortamı ile temel kütüphaneleri önceden yüklemiş olan bir işlem kalıbıdır. Sistem yeni bir uygulama açma istediğinde, Zygote işleminden fork() ile bir kopya alır. Bu yeni süreç, açılması gereken uygulamayı çalıştırmak için özelleşir. Böylece her uygulama başlatıldığında sıfırdan bir sanal makine oluşturulması gerekmemektedir; Zygote sayesinde uygulamalar daha hızlı bir şekilde açılır ve bellek tasarrufu sağlanır (birçok temel kütüphane zaten Zygote&#39;da yüklüdür, bu nedenle paylaşım yoluyla kopyalanır). Zygote&#39;dan fork edilen süreç, uygulamanın ana iş parçacığını yönetmeye başlar ve uygulamanın Activity veya Service gibi bileşenleri bu süreç içinde işler. Kısaca, ART katmanı ve Zygote mekanizması bir araya gelerek uygulama başlatmayı hızlı ve kaynaklı hale getirir.</p><p>Android Runtime, yalnızca uygulamalar için değil, aynı zamanda bazı sistem servisleri için de bir çalışma alanı sunar. Örneğin, Android’in önemli sistem süreçlerinden biri olan system\_server, içinde birçok Java ile geliştirilmiş sistem servisini barındırır ve ART üzerinde çalışır. ART’nin güvenlik katkıları da bulunmaktadır: Her uygulama kendi süreçleri dahilinde çalıştığından, bellek alanları ayrıdır ve bir uygulamanın diğerine bellek paylaşması genellikle mümkün değildir (Binder ve paylaşılan bellek dışında). Ayrıca, ART, uygulamaları Linux kullanıcıları olarak çalıştırdığı için (her uygulamanın kendine ait bir UID’si mevcuttur), kernel seviyesinde de bir izolasyon sağlanır. Yani ART, uygulamaların kodunu çalıştırırken bu kodun sandbox içinde kalmasını güvence altına alır; eğer bir uygulama kötü niyetli bir işlem yapmaya kalkışsa bile, Linux izinleri ve SELinux politikaları sayesinde kendi alanından çıkması engellenir.</p><p>Bir not olarak, Android 12 ile birlikte ART modüler bir yapı kazanmıştır. Artık Android Runtime bile bileşenler olarak Google Play Güncellemeleri aracılığıyla güncellenebilir hale gelmiştir. Bu durum, kritik performans iyileştirmeleri veya güvenlik düzeltmelerinin tüm cihazlara, büyük bir işletim sistemi güncellemesi beklemeden ulaşabilmesi açısından büyük bir adım olmuştur.</p><p>Kısacası, Android Runtime katmanı, Android uygulamalarının çalıştığı sanal makine ortamını temsil eder. Yüksek Seviyeli dillerle geliştirilen uygulamaların, temel donanım ve çekirdek kaynaklarına erişim elde etmesini sağlar. Bunu gerçekleştirirken, verimlilik adına derleme yöntemleri (JIT/AOT), bellek yönetimi için otomatik bellek temizleme ve hızla başlatma için Zygote gibi yenilikçi teknikler kullanır. Şimdi, ART&#39;ın hemen altında yer alan ve onunla uyum içinde çalışan Yerel Kütüphaneler katmanına geçelim.</p><blockquote><strong>Yerel Kütüphaneler Katmanı</strong></blockquote><p>Android yapısında, Yerel Kütüphaneler katmanı, ART&#39;nin ve Java çerçevesinin hemen altında yer alır. Bu katman, C/C++ dilleriyle yazılmış ve performans açısından önemli görevleri yerine getiren kütüphanelerden meydana gelir. Android&#39;in birçok üst düzey işlevinin altında bu yerel kütüphaneler yatar; bazı işlemlerin makine kodu ile yapılması, yönetilen dillerden biri olan Java&#39;dan çok daha etkili olmaktadır.</p><p>Yerel Kütüphaneler katmanını bir ara katman olarak düşünebiliriz: Bir taraftan çekirdek ve donanımla sıkı bir bağlantısı varken, diğer taraftan Java API&#39;lerine hizmet eder. Örneğin, Android&#39;de medya işlemleri üzerinde düşünelim. Bir uygulama, müzik çalmak için Java&#39;daki MediaPlayer API&#39;sini kullanır. Bu API&#39;nin gerçek işlevi gerçekleştirebilmesi için ses dosyasını analiz edecek ve çözümleyecek bir alt yapıya ihtiyaç vardır. Android, bu işlemi Stagefright adındaki bir C++ kütüphanesi aracılığıyla gerçekleştirir (Stagefright, Android’in medya oynatma motorudur). Yani, MediaPlayer API&#39;si çağrıldığında, uygulama Stagefright kütüphanesinin gereken fonksiyonlarını JNI (Java Native Interface) bağlantısı üzerinden çağırır. Benzer bir şekilde, tarayıcı ile alakalı işlemler için WebView API&#39;sinin altında WebKit/Blink motoru (C++ ile) bulunur; grafik işlemleri için Canvas API&#39;sinin altında Skia adında bir 2D çizim kütüphanesi (C++ ile) mevcuttur ve veri tabanı işlemleri için SQLiteDatabase API&#39;sinin altında cihazın yerel SQLite veritabanı motoru (C ile) çalışmaktadır. Bu örnekler, Java/Kotlin ile uygulama geliştiren kişilerin bu kütüphaneleri doğrudan görmediklerini, ancak Android sisteminin yüksek performans talep eden özelliklerinin arka planda yerel kütüphanelere bağlı olduğunu göstermektedir. Bu durumda uygulama geliştiricileri, düşük seviyeli C/C++ kodlarının karmaşıklığına takılmadan yüksek seviyeli API&#39;lerle çalışabilir; ancak arka planda C/C++ kodunun hızından ve verimliliğinden yararlanılmış olur.</p><p>Bu katmanın önemi birkaç sebebe dayanmaktadır:</p><ul><li><strong>Performans:</strong> Birçok kritik görev (grafik işleme, video/kolaylık kodlama, görüntü analizi, yapay zeka hesaplama, kriptografi vb. ) için C/C++ dilleri, yorumlu veya JIT derlenmiş dillerden çok daha hızlı çalışmaktadır. Örneğin, bir 3D oyun motoru, doğrudan donanımın grafik işlemcisinden (GPU) yararlanarak maksimum hızda çalışabilmek için büyük ölçüde C++ kullanır. Android bu gereksinimi, OpenGL ES ve Vulkan gibi grafik kütüphanelerini sisteme dahil ederek çözüyor; uygulamalar bu yerel kütüphanelere JNI ile erişerek GPU üzerinde grafik oluşturabiliyor. Video oynatma veya kamera görüntü işleme gibi işlemler, gerçek zamanlı olarak büyük miktarda veriyle çalışmak durumunda olduğundan, düşük seviyede optimize edilmiş kod gerektirir. Native Libraries katmanı, bu tür işlemlerin hızlı ve verimli şekilde gerçekleştirilmesine olanak tanır. Sonuç olarak, Android cihazlarda oyunlar akıcı bir performans sergileyebilir, 4K videolar kesintisiz oynatılabilir veya artırılmış gerçeklik uygulamaları çevreyi anında analiz edebilir; bu tür başarılar büyük ölçüde yerel kütüphanelerin sunduğu imkanlara dayanmaktadır.</li><li><strong>Donanım Özelliklerine Erişim ve Taşınabilirlik:</strong> Android cihazları, çeşitli işlemci yapıları (ARM, ARM64, x86 ve geçmişte MIPS gibi) bulunabilir. Yerel kütüphaneler, derleme aşamasında farklı yapılar için optimize edilerek Android platformu genelinde taşınabilirlik sağlar. Örneğin, Android’in standart C kütüphanesi Bionic, hem ARM hem de x86 mimarileri için derlenip benzer işlevsellik sunmaktadır. Uygulamalar, yukarıda bahsedilen API&#39;leri kullanırken hangi mimaride çalıştıklarını düşünmek zorunda kalmazlar. Ayrıca, donanım üreticileri, sağladıkları özel sürücüler veya HAL katmanı kodlarını bu yerel kütüphanelerle entegre edebilirler. Örneğin, Qualcomm, kendi yongalarında hızlı çalışan bir ses işleme kütüphanesini Android&#39;e dahil edebilir; bu kütüphane, HAL üzerinden Android&#39;in AudioService&#39;ine hizmet verebilir. Bu esneklik, üreticilerin yenilikçi donanım özelliklerini (yeni bir yapay zeka hızlandırıcısı veya özel bir görüntü sinyali işlemcisi gibi) Android&#39;e kazandırmalarını kolaylaştırmaktadır.</li><li><strong>Açık Kaynak ve Üçüncü Parti Kütüphaneler:</strong> Android, birçok açık kaynak kütüphaneyi içermektedir. Örneğin, OpenSSL (şifreleme işlemleri için), FFmpeg (medya kodlama/kod çözme için kısmen), LibPNG / WebP (görsel formatlar için) gibi kütüphaneler Android&#39;e entegre olmuştur. Google, bu kütüphaneleri mobil cihazlara uygun hale getirmek için çatallayıp optimize eder. Bu yeniden kullanım sayesinde, Android her işlevi sıfırdan yazmak zorunda kalmadan, mevcut en iyi çözümleri değerlendirme fırsatı bulur.</li></ul><p>Biraz da Android&#39;deki belli başlı yerel kütüphanelere örnekler verelim, ne işe yaradıklarını anlayalım:</p><ul><li><strong>Bionic libc:</strong> Android için standart C kütüphanesidir. Linux ekosisteminde yaygın olarak bulunan glibc yerine, Google, mobil cihazlar için daha hafif ve hızlı bir C kütüphanesi olan Bionic’i geliştirmiştir.Bionic, POSIX standartlarına oldukça yakın bir şekilde tasarlanmıştır; bu nedenle dosya işlemleri (open, read, write), ağ işlemleri (socket, connect) ve süreç yönetimi (fork, exec) gibi temel sistem çağrılarını içerir. Ancak Bionic’in kodu, mobil kullanım durumlarına göre optimize edilmiştir: Bellek kullanımı azdır, performansı yüksektir ve gereksiz özelliklerden arındırılmıştır. Bionic, Android’in çeşitli mimarilerde (ARM ve x86) sorunsuz çalışmasına olanak tanır. Uygulamalar, JNI kullanarak düşük seviyeli işlemler yapmak istediklerinde (örneğin, bir dosyayı C koduyla açmak gibi), Bionic kütüphanesinin fonksiyonlarını tercih ederler.</li><li><strong>libm:</strong> C dilinin standart matematik kütüphanesidir. Trigonometrik ve logaritmik fonksiyonlar ile üs alma, kök alma gibi işlemleri kapsar. Oyunlardan grafik hesaplamalarına kadar birçok alanda bu temel matematiksel işlemlere ihtiyaç duyulur ve bunlar donanım destekli bir şekilde (örn. FPU – kayan nokta işlemcisi kullanılarak) libm ile gerçekleştirilir.</li><li><strong>Grafik Kütüphaneleri (Skia, OpenGL ES, Vulkan):</strong> Skia, Android’in 2D grafik çizim motorudur; Canvas API’sinin arkasında Skia çalışmaktadır. Skia, ekranı piksel piksel çizerken yüksek bir performans sunar ve farklı donanım hızlandırmalarından yararlanabilir. OpenGL ES ve Vulkan ise 3D grafik çizimi ve GPU hesaplama için kullanılan API’lerdir. Android, oyunlar ve grafik yoğun uygulamalar için bu kütüphaneleri doğrudan sunmaktadır; uygulamalar, ya doğrudan NDK ile OpenGL/Vulkan kullanır ya da Unity gibi oyun motorları üzerinden bu kütüphaneleri kullanır. Bu sayede cihazın GPU’su etkin bir şekilde kullanılarak zengin 3D grafikler ve efektler elde edilir. Örneğin bir artırılmış gerçeklik uygulaması, Vulkan API’sini kullanarak kameradan aldığı görüntü üzerine 3D modellemeler ekleyebilir – tüm bu karmaşık işlemler C++ seviyesinde, GPU üzerinde yapılır ve sonuçlar hızla kullanıcıya iletilir.</li><li><strong>Multimedya Kütüphaneleri (Stagefright, OpenSL ES):</strong> Stagefright, Android’in temel medya oynatma ve kaydetme kütüphanesidir. İçerisinde ses ve video codec’leri (kodlayıcı/çözücü), konteyner format desteği ve medya demuxer’lar yer alır. Örneğin, bir MP4 video dosyasını oynatmak istediğinizde, Stagefright bunun içindeki H. 264 videoyu ve AAC sesi çözer, görüntüyü GPU’ya aktarır, sesi ise ses sürücüsüne iletir. OpenSL ES ise Android’de yüksek performanslı ses işlemleri için sağlanan bir kütüphanedir – oyunlarda düşük gecikmeli ses efektleri için kullanılmaktadır.</li><li><strong>WebKit/Blink (Android WebView):</strong> Android platformunda uygulamalar içerisinde web içeriği görüntülenmesini mümkün kılan WebView öğesi, arka planda Chromium’un açık kaynaklı render motoru olan Blink’i kullanmaktadır. Bu kütüphane, HTML, CSS ve JavaScript gibi web içeriklerini işler ve uygulama içinde bir web sayfası gibi sunar. Örneğin, Twitter uygulamasında bir bağlantıya tıkladığınızda, açılan sayfa, WebView ile Blink motoru aracılığıyla görüntülenir.</li><li><strong>SQLite:</strong> Android, basit yerel veritabanı gereksinimleri için uzun bir süre boyunca SQLite kullanmaktadır. SQLite, bir SQL veritabanını dosya tabanlı bir formatta sunan ve herhangi bir sunucuya ihtiyaç duymayan bir C kütüphanesidir. Uygulamalar, SQLiteDatabase Java API’si aracılığıyla veritabanı komutları gönderdiklerinde, arka planda SQLite kütüphanesi devreye girer ve sonuçları geri döndürür. Küçük uygulama verilerinin depolanması, yapılandırması veya önbellekleme gibi amaçlarla SQLite oldukça işlevseldir ve hemen hemen her Android cihazında mevcuttur.</li></ul><p>Android&#39;in yerel kütüphaneler katmanı geniş bir yapıya sahiptir ve her bir bileşen kendi alanında özgün bir uzmanlığa sahiptir. Bu katman, Android&#39;in etkili, çok yönlü ve yüksek performanslı olmasının başlıca sebeplerinden biridir. Uygulamaların ihtiyaç duyduğu yoğun işlemler, derin seviyelerde gerçekleştirilirken, üst katmanda basit arayüzler olarak yansıtılmaktadır.</p><p>Sonuç olarak, Yerel Kütüphaneler katmanı, Android’in beyin fonksiyonu gören üst katmanlar ile güç anlamına gelen alt katmanlar arasında bir ara katman işlevi görür. Gerekli performansı sağlamakta, donanım yeteneklerini üst düzeye taşımakta ve uygulamaların zengin işlevselliğe sahip olmasına olanak tanımaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*ymoS4ZDQowY4X9WKHN7Z7g.png" /></figure><p>Devam Yazısı -&gt; <a href="https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-10755e3ba51c">PART 3— Yönetim ve Kullanıcı Arayüzü</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b068f550e104" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ANDROID SİSTEM MİMARİSİ]]></title>
            <link>https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-e6cadfdb2ff3?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6cadfdb2ff3</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[android-apps]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sun, 12 Oct 2025 14:00:35 GMT</pubDate>
            <atom:updated>2025-10-12T14:49:41.222Z</atom:updated>
            <content:encoded><![CDATA[<h3>Android Sistem Mimarisi: Katmanlara Yolculuk</h3><p>PART 1 — Temel ve Donanım</p><p>Android’in yapısı, aslında katmanlar dizisi şeklinde oluşturulmuştur. En alt kısımdaki çekirdekten en üstteki uygulamalara kadar her bir katmanın belirli görev ve sorumlulukları vardır ve diğer katmanlarla tanımlı arayüzler aracılığıyla iletişim kurmaktadır. Bu yöntemle geliştiriciler yüksek seviyede gönül rahatlığıyla uygulama geliştirebilirken, alt seviyede sistem performansı ve güvenliği de sağlanmaktadır. Bu blog serimizde de bu yapıyı yani Android işletim sisteminin mimari katmanlarını birlikte gözden geçireceğiz. Anlatımımız sırasında Linux Kernel, Donanım Soyutlama Katmanı (HAL), Android Runtime (ART), Yerel (Native) Kütüphaneler, Java API Çerçevesi ve Sistem Servislerini tek tek inceleyeceğiz. Ayrıca en üstteki Uygulama Katmanı ile katmanlar arasındaki ilişkiler hakkında da bilgi vererek gerçek hayattan örneklerle konuyu daha anlaşılır hale getireceğiz. Bu serinin ilk yazısı olan Temel ve Donanım’da bu mimarinin temeli olan Linux Kernel Katmanı ile işletim<br>sistemi ve donanım arasında bir köprü görevi üstlenen HAL Katmanına değiniyor olacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/549/1*q9osIdFXAjeapQehHHJEhA.png" /></figure><p>Şemada görüldüğü gibi Android, bloklar halinde üst üste yerleştirilmiş bir yapı ile gösterilmektedir. Şimdi en alt noktadan başlayarak bu blokların içeriğine göz atalım.</p><blockquote><strong>Linux Çekirdek Katmanı</strong></blockquote><p>Android mimarisinin en alt kısmında Linux çekirdeği yer almaktadır. Android, geleneksel Linux çekirdeğini temel alarak, fakat mobil cihazlara özel bazı ilaveler ve değişikliklerle kullanmaktadır. Bu katman tüm sistemin temelini oluşturur; üstteki bileşenler, donanım ile ilgili işlemler ya da çekirdek düzeyindeki hizmetler için Linux çekirdeğine başvurur. Kısacası, çekirdek Android için temel altyapıdır ve donanım ile yazılım katmanları arasında bir köprü işlevi görür.</p><p>Linux çekirdeğinin Android’deki başlıca işlevleri şunlardır:</p><p><strong>Güvenlik:</strong> Çekirdek, uygulamalar ile sistem bileşenleri arasında yalıtım (sandboxing) yaparak ve erişim kontrollerini zorunlu kılarak genel sistem güvenliğini sağlamaktan sorumludur. Android, Linux çekirdeğinde bulunan SELinux güvenlik modülünü zorunlu olarak aktifleştirir. SELinux, Zorunlu Erişim Kontrolü (MAC) adı verilen bir politika doğrultusunda her bir işlem ve kaynak için güvenlik etiketleri atar ve hangi işlemin hangi kaynağa erişebileceğini merkezi bir politikayla belirler. Böylece kötü niyetli bir uygulama, çekirdek seviyesindeki kuralları aşarak başka bir uygulamanın verilerine ya da sistem kaynaklarına ulaşamaz. Android 5. 0&#39;dan itibaren SELinux “enforcing” modunda faaliyet göstermektedir; bu, politika ihlali oluşturmaya çalışan işlemlerin çekirdek tarafından engelleneceği anlamına gelir. Özetle, çekirdek katmanı Android’de güvenliğin ilk savunma hattıdır.</p><p><strong>Bellek Yönetimi:</strong> Çekirdek, fiziksel ve sanal belleğin etkili biçimde kullanılmasını sağlar. Uygulamalara ayrı bellek alanları tahsis eder, gereksiz bellek alanlarını serbest bırakır ve sayfalama gibi yöntemlerle bellek kullanımını optimize eder. Android cihazlarda bellek sınırlı olduğundan, çekirdek seviyesindeki bellek yöneticisi hangi uygulamaların bellekte kalacağını ve hangilerinin sonlandırılacağını (LRU — En Son En Az Kullanılan prensibiyle) belirler. Bu mekanizma, arka planda kullanılmayan uygulamaların gerektiğinde kapanarak belleği boşaltmasını ve ön planda çalışan uygulamalara yer açmasını sağlar. Sonuç olarak, bellek yönetimi katmanı sistemin akıcı bir şekilde çalışmasını ve uygulamalar arasında izolasyonu sağlamaktadır.</p><p><strong>Süreç Yönetimi:</strong> Çekirdek, çalışan tüm süreçlerin (uygulamalar ve sistem süreçleri) CPU kullanımı ve diğer kaynaklar açısından adil ve düzenli bir biçimde işlemesini temin eder. Linux çekirdeğinin işlem zamanlayıcısı (scheduler), her süreç için CPU zaman dilimlerini dağıtır ve öncelik sıralaması yapar. Örneğin, kullanıcı arayüzüyle etkileşimde bulunan bir uygulama (ekrana dokunduğunuzda yanıt veren uygulama gibi) daha yüksek öncelik alırken, arka planda güncelleme gerçekleştiren bir uygulama daha düşük öncelik ile çalışır. Böylelikle, sistem birçok uygulamanın aynı anda aktif olduğu durumlarda bile kaynakları etkili bir şekilde dağıtarak herhangi bir takılma olmaksızın çalışabilir.</p><p><strong>Ağ İletişimi (Network Stack):</strong> İnternet ve diğer ağ bağlantılarına ilişkin temel işlemler, çekirdek tarafından gerçekleştirilir. TCP/IP protokolü, UDP iletimi ve soket arayüzleri gibi düşük düzey ağ işlevleri, Linux çekirdeğinin ağ yığında çalışmaktadır. Android’e özel bir durum olarak, her uygulamanın kendi kullanıcı kimliği (UID) ile faaliyet göstermesi sayesinde, çekirdek Paranoid Networking adı verilen bir yöntemle</p><p>uygulamaların ağ erişimini denetler. Kısaca ifade etmek gerekirse, her uygulama yalnızca kendi izinleri çerçevesinde internete bağlanabilir; böylece bir uygulamanın izinsiz ağa erişmesi çekirdek seviyesi düzeyinde engellenir. Örneğin, eğer bir kamera uygulamasının internet izni yoksa, çekirdek bu uygulamanın herhangi bir ağ soketi oluşturmasına izin vermez. Bu, kötü niyetli uygulamaların veri sızdırmasını engellemede önemli bir güvenlik fonksiyonudur.</p><p><strong>Donanım Sürücüleri:</strong> Android cihazınızdaki fiziksel tüm donanımlar (kameralar, GPS alıcıları, Wi-Fi/Bluetooth modülü, dokunmatik ekran gibi), Linux çekirdeği yönetimindeki sürücüler aracılığıyla kontrol edilmektedir. Donanım üreticileri, cihazlarının bileşenleri için Linux çekirdek modülleri hazırlayarak Android ile entegre ederler. Çekirdek, bu sürücüleri yüker ve üst katmanların kullanımı için standart bir şekilde sunar. Örneğin, bir kamera sensörü için sürücü modülü, kamera donanımından gelen görüntü bilgilerini alır ve üst katmandaki yazılımların kullanımına uygun hale getirir. Benzer şekilde, dokunmatik ekran sürücüsü, parmağınızın ekran üzerindeki konumunu algılayarak ilgili üst katmanlara iletir. Kısacası, çekirdek sürücü modeli, farklı üreticilerin donanımlarının Android içinde uyumlu bir şekilde çalışmasını sağlar.</p><p><strong>Binder IPC Mekanizması:</strong> Android’e özgü en önemli yeniliklerden biri, çekirdeğe eklenen Binder sürücüsüdür. Binder, Android süreçleri arasında yüksek performanslı ve güvenli bir süreçler arası iletişim sağlamakta kullanılır. Çekirdek içindeki /dev/binder sürücüsü, bir uygulamanın ya da sistem servisinin başka bir süreçteki servise mesaj göndermesine ve yanıt almasına olanak tanır. Binder sayesinde üst katmanlardaki sistem servisleri ve uygulamalar birbirleriyle iletişim kurabilir. Örneğin, bir uygulama konum bilgisi almak istediğinde, kendi sürecinde çalışan LocationManager API’sini kullanır; bu çağrı arka planda Binder IPC aracılığıyla sistem sunucusundaki Konum Servisi’ne iletilir. Binder, mesajı gönderirken gönderen uygulamanın kimliğini (UID) de ekler, bu sayede hedef servis isteğin kimden geldiğini bilerek izin kontrolü yapar. Android Binder mekanizması, hem hız hem de verimlilik açısından son derece etkilidir. İletişim kurmadan bilgi aktarımı gerçekleştirir ve her isteği tanımlayarak güvenlik sağlar. Bu açıdan, Android’in katmanları arasında temel bir rol üstlenen iletişim altyapısı Binder’dır diyebiliriz.</p><p>Kısaca özetlemek gerekirse, Linux çekirdek katmanı Android’in temel yapı taşını oluşturmaktadır. Bunu bir evin temeli gibi düşünebilirsiniz: Üstünde yer alan tüm yapıları taşır ve destekler. Eğer çekirdek olmasaydı, donanımlarla iletişim kuramaz, uygulamalar çalıştıramaz veya güvenliği sağlayamazdık. Android, Linux çekirdeğinin gelişmişliğinden ve dayanıklılığından faydalanırken kendi ihtiyaçlarına uygun olarak bu yapıyı geliştirmiştir.</p><p>Şimdi, çekirdeğin hemen üstündeki katmana, donanım ile işletim sistemi arasında bağlantı sağlayan HAL katmanına geçelim.</p><blockquote><strong>Donanım Soyutlama Katmanı (HAL)</strong></blockquote><p>Android HAL (Donanım Soyutlama Katmanı), çekirdek donanım sürücülerini yönetirken, işletim sistemi ile donanım arasında bir ara katman görevi üstlenir. Bu katmanın ana hedefi, üst katmanlardaki Android yapısını donanıma bağlı olmaktan kurtarmaktır. Bu sayede Android işletim sistemi ve uygulamalar, donanımın işleyişi hakkında bilgi sahibi olmadan, o donanımı bir arayüz üzerinden kullanabilirler. Şemadaki HAL katmanı, kernelin hemen üstünde yer alır ve pratikte birçok kütüphane modülü ile arayüz tanımları olarak değerlendirilir. Donanım üreticileri ise cihazın kamera, ses, sensörler gibi parçaları için HAL kütüphaneleri geliştirir ve bunları sisteme entegre ederler.</p><p>Android’in üst katmanındaki framework ya da sistem servisleri, ihtiyaç duyduğu donanımla iletişim kurmak istediğinde bu HAL arayüzleri üzerinden sorgular gönderir. HAL katmanı ise bu sorguları alarak ilgili kernel sürücüsüne iletir ve sonucu geri iade eder. Böylece üst katman, donanımın marka veya model bilgilerini ya da düşük seviyeli protokol detaylarını bilmek zorunda kalmaz; yalnızca HAL tarafından sunulan standart API’yi kullanır. Daha somut bir örnek vermek gerekirse, bir uygulama kamera ile fotoğraf çekmek istediğinde şu adımlar izlenir:</p><ul><li>Uygulama, Java seviyesindeki Kamera API’lerini kullanır. Bu istek, Android’in CameraService sistem servisine ulaşır.</li><li>Ardından CameraService, donanım soyutlama katmanındaki Kamera HAL modülüne bir talep gönderir.</li><li>Kamera HAL kütüphanesi, üretici tarafından geliştirilmiştir ve kamera donanımını kontrol etmek için gerekli C/C++ kodlarını içerir; örneğin sensörü açma, görüntü akışını başlatma ve pozlamayı ayarlama gibi işlemler. Bu HAL modülü, kerneldeki kamera sürücüsü ile etkileşimde bulunarak gerekli işlemleri gerçekleştirir ve sonuçları üst katmana iletir.</li><li>Bunun sonucunda uygulama, tek bir yüksek seviyeli çağrı ile fotoğraf çekmiş olurken, arka planda HAL aracılığıyla donanım kontrol edilip görsel veriler elde edilmiştir. Burada uygulama ya da Android framework’ü, kamera donanımının işleyişi hakkında detaylı bilgiye sahip değildir; tüm bu bilgilendirmeler, HAL içindeki üretici kodunda gizlenmiştir.</li></ul><p>Android’in ilk dönemlerinden beri HAL konsepti mevcut olmasına rağmen, Android 8. 0 (Oreo) sürümü ile birlikte HAL altyapısında önemli bir yenilik gerçekleştirilmiştir. Project Treble adı verilen mimari değişiklikle birlikte, HAL arayüzleri standart hale getirilmiş ve versiyonlama yapılabilir duruma getirilmiştir. Bu amaçla Android 8 ile HIDL (Donanım Arayüzü Tanım Dili) olarak bilinen bir tanım dili tanıtılmıştır. HIDL, HAL için arayüzleri tanımlamada kullanılabilen, programlama dilinden bağımsız bir dildir ve her bir donanım bileşeni için tutarlı, belirli sürüm numaralarına sahip API’ler tanımlamak mümkün hale geldi. Bu sayede, Android işletim sistemi güncellense bile, üreticilerin HAL uygulamaları belirli bir arayüzü desteklediği sürece, uyum kaybı yaşamadan çalışabilir durumda olabiliyordu. Daha güncel Android sürümlerinde (Android 10 ve sonrası), Google HAL için AIDL (Android Arayüz Tanım Dili) adında başka bir arayüz tanım yöntemi önerisi sunmaya başladı. AIDL aslında Android üzerinde uzun bir zamandır bulunan, Binder IPC için kullanılan bir tanım dilidir. Android 13 itibarıyla yeni HAL geliştirmelerinin büyük bir kısmı AIDL ile tanımlanmaktadır. Kısaca özetleyecek olursak:</p><ul><li><strong>HIDL</strong> — Android Oreo ile birlikte gelen, HAL arayüzlerini tanımlamak için kullanılan ve versiyon kontrolü sunan bir programlama dili. Üreticiler, HIDL tanımlarına uygun HAL kütüphaneleri geliştirerek sistemi donanımla entegre ettiler.</li><li><strong>AIDL</strong> — Android’in mevcut IPC dilinin, HAL için uyarlanmış versiyonu. Daha basit bir sözdizimi sunuyor ve Android 13 sonrası HAL’ler için tercih edilen yöntem haline gelmiştir.</li></ul><p>Bu arayüz tanım dilleri sayesinde Android’in HAL seviyesi daha modüler bir yapıya kavuştu. Örneğin, aynı cihazda farklı sürümlere sahip bir kamera HAL’i ile bir ses HAL’i yan yana çalışabilir, sistem bunları yönetebilir (bu HIDL sayesinde mümkün hale gelmiştir). Ayrıca, yeni bir Android sürümü çıktığında üreticiler yalnızca HAL kütüphanelerini güncelleyerek cihazlarını uyumlu hale getirebilir, tüm sistemi baştan düzenlemek zorunda kalmazlar. Kısacası, HAL katmanı Android’in donanımdan bağımsızlığını sağlar ve cihaz çeşitliliğiyle uyum sağlama yeteneğini artırır.HAL mimarisinin işleyişine de biraz değinelim. Android’de HAL bileşenleri genel olarak iki tipte bulunur:</p><p><strong>Binder-tabanlı HAL (Hizmet olarak çalışan HAL):</strong> Android 8. 0 sonrasında çoğu HAL bu modelo geçiş yaptı. Bu modelde HAL modülü, ayrı bir servis süreci olarak işler ve Binder IPC üzerinden talepler alır. Örneğin kamera HAL’i, sistem açıldığında kendi süreci içinde başlar ve hizmet yöneticisine (ServiceManager) kaydolur. Uygulama tarafındaki CameraService, bir binder çağrısıyla bu HAL hizmetinden yararlanır. Bu yaklaşımın avantajı, HAL’in çökmesinin veya hatalarının ana sistemi etkilememesidir — çünkü ayrı bir süreçte yer almaktadır. Güvenlik ve kararlılık artar; zira hatalı bir HAL servisinin çökmesi durumunda sadece o servisi yeniden başlatmak yeterlidir, diğer bileşenler çalışmaya devam eder. Dezavantajı ise her çağrıda IPC maliyeti olduğu için, milisaniyelerin önemi olan zaman duyarlı işlerde (örneğin yüksek hızda veri iletimi gereken durumlar) küçük bir ek yük getirmesidir.</p><p><strong>Aynı süreçte çalışan HAL (In-process HAL):</strong> Bazı özel durumlarda, HAL istemcisi ile HAL’in aynı bellek alanını paylaşması tercih edilir. Bu genellikle grafik veya yüksek hızlı bellek paylaşımı gerektiren bileşenlerde olur. Örneğin, Android’de grafik çiziminde kullanılan OpenGL ES HAL’i veya Vulkan HAL, uygulamaya daha yakın bir konumda, aynı süreç içinde çalışabilir. Böylece bir çerçeve çizilirken veya GPU ile etkileşim sağlanırken binder IPC’nin getirdiği gecikme ortadan kalkar; veriler doğrudan paylaşılabildiği için maksimum performans elde edilir. Tabii bu modelin dezavantajı, HAL kodunda bir hata oluşursa uygulamayı da etkileme olasılığıdır.</p><p>HAL katmanının başarılı bir şekilde çalışabilmesi, büyük oranda üreticilerin doğru bir biçimde uygulama yapmasına bağlıdır. Android bazı belirli arayüzler sunsa da, HAL kütüphaneleri genellikle üreticilerin kapalı kaynaklı C/C++ kodlarından oluşmaktadır.</p><p>Sonuç olarak, HAL katmanı donanım ve yazılım arasında bir çevirmen rolü üstlenir. Üst katmanlar, “donanımda şu işlemi yap” der, HAL bunu donanımın anlayacağı dile çevirir, çekirdek aracılığıyla işlemi gerçekleştirir ve sonucu yine üst katmana iletir. Böylece Android işletim sistemi, binlerce farklı cihaz modelinde büyük değişiklikler yapmadan çalışabilmektedir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*ymoS4ZDQowY4X9WKHN7Z7g.png" /></figure><p>Devam Yazısı -&gt; <a href="https://medium.com/@yunuscakici.08/android-si%CC%87stem-mi%CC%87mari%CC%87si%CC%87-b068f550e104">PART 2— Çalışma Ortamı ve Hız</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6cadfdb2ff3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kioptrix Level 1 Çözümü]]></title>
            <link>https://medium.com/@yunuscakici.08/kioptrix-level-1-0-%C3%A7%C3%B6z%C3%BCm%C3%BC-93935d086286?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/93935d086286</guid>
            <category><![CDATA[kioptrix]]></category>
            <category><![CDATA[kioptrix-level-1]]></category>
            <category><![CDATA[kioptrix-1]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sat, 14 Dec 2024 12:59:17 GMT</pubDate>
            <atom:updated>2024-12-15T00:41:31.379Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*0jOpt00q-1LV85rKn1acGQ.png" /></figure><p>Bugün Kioptrix Level 1 zafiyetli makinesini çözdük. İyi Okumalar ..:)</p><p>1-) Öncelikle iki makinemi de ayağı kaldırdıktan sonra kullanacağım kali makinemin ip adresini öğreniyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IgsAz3yfe_phVZ6gEVBIWA.png" /></figure><p>2-) Sonrasında Kioptrix Makinemin ip adresini öğrenmek için ‘bettercap’ i kullanıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mJ5d0taDgJT9hobOYJFhXQ.png" /></figure><p>3-) Sonrasında bu ip adresini ‘nmap’ üzerinden araştırıyorum ve 139 portunda bir samba açığını buldum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EOdJeZB0Hak17c-NxwJhSA.png" /></figure><p>4-) Sonrasında ‘msfconsole’ komutuyla metasploit’e girerek ‘search samba’ komutunu yazıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LTAuZSoMBuMS4y9UhJnnQg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xore-WyIzQFEYT4CMIlSPg.png" /></figure><p>5-) Sonrasında 70+ sonuç çıkması sonucu aramayı biraz daraltarak bir kaç adım önce -0 sayesinde nmapte arama yaparken öğrendiğimiz işletim sistemi bilgisini de filtre ye dahil ettim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jR0ItMhd_us_UQRxO8GDFQ.png" /></figure><p>6-) Sonrasında ‘show payloads’ komutu ile yapılabilecek işlemlerden ben sshreverse’i seçiyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7DgRyoEfKoTjqOhg6n9srg.png" /></figure><p>7-) Sonrasında ‘set PAYLOAD generic/shell_reverse_tcp’ komutu ile shell_reverse işlemini yapıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H19snXI5p5V7wOuqwWDbkA.png" /></figure><p>8-) Sonrasında ‘set rhosts 192.168.147.135’ komutu ile ssh_reverse yapacağımız makinenin ip’sini giriyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*86rKI8HmhPF6M4IFvkQDxg.png" /></figure><p>9-) Sonrasında ‘run’ komutu ile saldırıyı başlatıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cas_tVzYmuQYkKrefAlqWA.png" /></figure><p>10-) Sonrasında ‘pwd’ ile hangi dizinde olduğumuz öğrenip bulunduğumuz dizinden var dizinine geçiyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ZaASr11MIHsXIUMZFosGw.png" /></figure><p>11-) Sonrasında var dizinide ‘ls’ komutunun ardından burada mail dosyası gözümüze çarpıyor ve mail dosyasına giriyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eftiHOyKxBqT7RFfSJeAJQ.png" /></figure><p>12-) Sonrasında dikkatimizi çeken root dosyasını ‘cat root’ komutu ile okuyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E9lb756UDe75v6DX0vhPFA.png" /></figure><blockquote>Ve Kioptrix Seviye 1 ‘i başarıyla tamamladık.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93935d086286" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fortigate ‘te IPV4 Policy (Kural Oluşturma)]]></title>
            <link>https://medium.com/@yunuscakici.08/fortigate-te-ipv4-policy-kural-olu%C5%9Fturma-f96d0b0388db?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f96d0b0388db</guid>
            <category><![CDATA[policy]]></category>
            <category><![CDATA[fortinet]]></category>
            <category><![CDATA[fortigate]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sun, 08 Dec 2024 16:47:47 GMT</pubDate>
            <atom:updated>2024-12-08T16:47:47.681Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/610/1*riuwTByB8RoEGxs51V7xTw.png" /></figure><p>Blog serimizin ilk iki bölümünde <strong>Web Filter</strong> ve <strong>Application Control</strong> üzerinde durmuştuk. Bugün ise bu öğrendiklerimize de değinerek <strong>kural nasıl yazılır</strong> konusuna değineceğiz.<br>Bu blog yazılarına aşağıdaki bağlantılardan erişebilirsiniz:</p><ul><li><a href="https://medium.com/@yunuscakici.08/fortigatete-web-filter-636c7f12aadf">Web Filter</a></li><li><a href="https://medium.com/@yunuscakici.08/fortigatete-application-control-e05bff1118a2">Application Control</a></li></ul><p>Bu blog yazısını yazarken, <strong>interfaceler</strong> hazır olarak elimizde bulunacak. Ancak, baştan başlıyorsanız öncelikle interfacelerinizi sanal makine üzerinden oluşturmanız gerekmektedir.<br>Biz aşağıdaki yapılandırmayı kullanacağız:</p><ul><li><strong>Port1</strong> → WAN (Türkcell)</li><li><strong>Port2</strong> → Muhasebe</li><li><strong>Port3</strong> → Pazarlama</li></ul><p><strong>Hadi Başlayalım!</strong></p><h3>Kural Yazımı Adımları</h3><ol><li><strong>Policy &amp; Objects &gt; IPv4 Policy</strong> sekmesine giriyoruz.</li><li>Sol üst taraftaki <strong>+Create New</strong> butonuna tıklayarak aşağıdaki sayfaya erişiyoruz:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WEEw65O3aNGfp6cKCq5Iig.png" /></figure><p>Şimdi bu bölümü biraz inceleyelim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*UGDUWGP8dK-rZNFcAcjR2Q.png" /></figure><ul><li><strong>Name</strong> → Kuralın ismi.</li><li><strong>Incoming Interface</strong> → Trafiğin nereden (hangi interfacedan) geleceği.</li><li><strong>Outgoing Interface</strong> → Trafiğin nereye (hangi interface’e) ulaşacağı.</li><li><strong>Source</strong> → Trafiğin kimden (hangi kaynaktan) çıkacağı.</li><li><strong>Destination</strong> → Trafiğin kime (hangi hedefe) ulaşacağı.</li><li><strong>Schedule</strong> → Kuralın hangi zaman aralığında aktif olacağı.</li><li><strong>Service</strong> → Kullanılacak servisler (SSH, FTP, vb.).</li><li><strong>Action</strong> → Kuralın işlemi izin verip vermeyeceği (Accept veya Deny).</li></ul><blockquote>F<strong>irewall Network Options</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*NEhPFa2-fqIvpaJezrffBw.png" /></figure><ul><li><strong>NAT Ayarı</strong>:<br>Bu ayar, <strong>LAN → WAN</strong> trafiği için aktif edilir. NAT (Network Address Translation), aynı ağ üzerindeki birden fazla cihazın aynı public IP’yi kullanarak internete erişmesini sağlar. Böylece her cihaz için ayrı bir public IP gereksinimini ortadan kaldırır.</li></ul><blockquote><strong>Security Profiles</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*W6wJUOyHcpSKld4ulVKk_A.png" /></figure><ul><li>Bu bölümde, işlem sırasında kullanılacak güvenlik profilleri ayarlanır.<br>Daha önceki blog yazılarımızda <strong>Web Filter</strong> ve <strong>Application Control</strong> konularına değinmiştik. Diğer kısımlara da ilerleyen yazılarımızda değineceğiz …</li></ul><blockquote><strong>Logging Options</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*iibRmqxIRWgIOCzmBqrx2A.png" /></figure><p>Logların ne zaman tutulacağını ayarladığımız bölümdür.</p><ul><li><strong>Security Events</strong>: Sadece güvenlik tehditlerinde log tutulur.</li><li><strong>All Sessions</strong>: Her işlem için log tutulur.</li></ul><h3>Örnek Kurallar</h3><h4>Örnek 1: Muhasebe → Pazarlama</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pJwRhUd4ZKkQisL9tB10VA.png" /></figure><ul><li>Bu kısımda ayarlarımızda tüm kullanıcılardan tüm kullanıcılara iletişimi dikkate aldık, bu yüzden <strong>Source</strong> ve <strong>Destination</strong> kısımlarımızı “All” seçtik.</li><li>Bu kuralın her zaman aktif olması için <strong>Schedule</strong> kısmımızı “Always” seçtik.</li><li><strong>Action</strong> kısmında da “Accept” seçerek bu kuralın izin veren bir kural olduğunu dile getirdik.</li><li>LAN → LAN bir iletişim olduğu için <strong>NAT</strong> kısmımız <strong>disable</strong> durumda.</li><li><strong>Security Profiles</strong> kısmında hiçbir kısım aktif olmadığı için herhangi bir filtreleme işlemi yapmamış bulunuyoruz.</li><li>Log’ları “All Sessions” olarak ayarladık ve bu sayede tüm işlemlerin loglarını görmüş olacağız.</li><li>Son olarak da kuralımızı <strong>Enable</strong> yaparak ve <strong>OK</strong> tuşuna basarak bu trafiğin bundan sonraki işlemlerde Fortigate Firewall üzerinden gerçekleştirilmesini sağlamış bulunuyoruz.</li></ul><h4>Örnek 2: Muhasebe → WAN (Türkcell)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WvLW_299DCyRJ8CQnhpRzA.png" /></figure><ul><li>Bu kısımda ayarlarımızda tüm kullanıcılardan tüm kullanıcılara iletişimi dikkate aldık, bu yüzden <strong>Source</strong> ve <strong>Destination</strong> kısımlarımızı “All” seçtik.</li><li>Bu kuralın her zaman aktif olması için <strong>Schedule</strong> kısmımızı “Always” seçtik.</li><li><strong>Action</strong> kısmında da “Accept” seçerek bu kuralın izin veren bir kural olduğunu dile getirdik.</li><li>LAN → WAN bir iletişim olduğu için <strong>NAT</strong> kısmımız <strong>enable</strong> durumuna getiriyoruz.</li><li><strong>Security Profiles</strong> kısmında bu kuralda daha önceki blog yazılarımızda da değindiğimiz <strong>Web Filter</strong> ve <strong>Application Control</strong> kısımlarını aktif ediyoruz.<br>Bu sayede bu kural üzerinden sağlanacak olan ağ üzerindeki aktivitelere kısıtlama getirmiş oluyoruz.</li><li>Log’ları “All Sessions” olarak ayarladık ve bu sayede tüm işlemlerin loglarını görmüş olacağız.</li><li>Son olarak da kuralımızı <strong>Enable</strong> yaparak ve <strong>OK</strong> tuşuna basarak bu trafiğin bundan sonraki işlemlerde Muhasebe çalışanlarının internete çıkışını Fortigate Firewall üzerinden gerçekleştirilmesini sağlamış bulunuyoruz.</li></ul><p><strong>Not:</strong></p><ul><li><strong>Policy &amp; Objects</strong> sekmesinde yazılan kurallar, yukarıdan aşağıya doğru sırayla uygulanır.</li><li>Eğer aynı trafiğe yönelik birden fazla kural varsa, en üstteki kural geçerli olur. Alt sıradaki kurallar işlenmez.</li><li>Örneğin, iki farklı “Muhasebe → Pazarlama” kuralı varsa, üst sıradaki kural aktif olur ve alt sıradaki kural devre dışı kalır.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f96d0b0388db" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fortigate’te Application Control]]></title>
            <link>https://medium.com/@yunuscakici.08/fortigatete-application-control-e05bff1118a2?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e05bff1118a2</guid>
            <category><![CDATA[fortigate]]></category>
            <category><![CDATA[application-control]]></category>
            <category><![CDATA[fortinet]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Mon, 02 Dec 2024 22:48:20 GMT</pubDate>
            <atom:updated>2024-12-02T22:48:20.191Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*rDBabC9p956vdx1gLaJfxg.png" /></figure><h4>Application Control Nedir?</h4><p><strong><em>Fortigate Firewall</em></strong> tarafında, aynı ağdaki kullanıcıların hangi uygulamalara girebileceğini veya giremeyeceğini belirlediğimiz kısım <strong><em>Application Control</em></strong> bölümüdür.<br>Burada oluşturmuş olduğumuz filtreleri kurallarımıza ekleyerek, kullanıcıların ağımıza bağlıyken kullandıkları uygulamaları kontrol altında tutmamızı sağlar.<br>Yani uzun lafın kısası, bu serinin bir önceki blog konusu olan <strong><em>Web Filter</em></strong>’ın uygulamalar özelindeki versiyonu diyebiliriz.<br><a href="https://medium.com/@yunuscakici.08/fortigatete-web-filter-636c7f12aadf"><strong><em>([Web Filter blog yazımıza buradan ulaşabilirsiniz.])</em></strong></a></p><h4>Application Control Nasıl Oluşturulur?</h4><p>İlk olarak <strong><em>Security Profiles &gt; Application Control</em></strong> sekmesine giriyoruz. Sonrasında, sol üstteki <strong><em>+Create New</em></strong> butonuna tıklayarak aşağıdaki sayfaya erişiyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tgk-UlFeJSDdK1awlrX24A.png" /></figure><p>Şimdi gelin buraya biraz göz atalım…</p><blockquote><strong>Categories:</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*ufpTEjwlSPu4cnASQpn3ew.png" /></figure><p>Yukarıda görüldüğü üzere, bu kısımda bizi çok sayıda kategori karşılamaktadır. Bu kategoriler, o alandaki uygulamaları içerir.<br>Aynı <strong><em>Web Filter</em></strong>’da olduğu gibi, ancak daha önce belirttiğimiz üzere, bu sefer uygulamalar bazında oluşturulmuştur.<br>Örneğin, Instagram uygulaması Social Media kategorisi altındadır.</p><p><strong><em>Kısa Bir Not:</em></strong><br>Web Filter ve Application Control birbirinden bağımsız çalışır.</p><p>Bu duruma örnek vermek gerekirse:<br>Yukarıda belirttiğimiz üzere, Instagram uygulaması Social Media kategorisi altındadır. Bu kategoriyi “<strong><em>Block</em></strong>” durumuna getirmek,<br>Instagram uygulamasına o ağ üzerinden girilemeyeceği anlamına gelir.</p><p>Ancak, <strong><em>Web Filter</em></strong> aracılığıyla instagram.com’u “<strong><em>Block</em></strong>” durumuna getiren bir kural yazılmadığı bir senaryoda, kullanıcılar o ağ üzerinden web aracılığıyla ilgili sayfayı ziyaret ederek Instagram’a giriş yapabilirler.</p><p>Bu örneğin tam tersi de geçerlidir.<br>Eğer <strong><em>Application Control</em></strong> ile “<strong><em>Block</em></strong>” durumunda bir kural yazılmamışsa, instagram.com <strong><em>Web Filter</em></strong> aracılığıyla “<strong><em>Block</em></strong>” durumuna getirilse bile kullanıcılar o ağda uygulama üzerinden Instagram’a erişebilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*dXPaLyL2uXD2bLxfJaYDDA.png" /></figure><p>Application Control’de 4 adet izin türü vardır. Bunlar:</p><p><strong>Allow:</strong> Erişim izni verir.<br><strong>Monitor:</strong> Erişim izni verir ve tüm logları tutar.<br><strong>Block:</strong> Erişimi engeller ve tüm logları tutar.<br><strong>Quarantine:</strong> Şüpheli uygulamaları izole eder.<br>Bunlardan en yaygın kullanılan ikisi <strong><em>Monitor</em></strong> ve <strong><em>Block</em></strong>’tur.</p><p>Son olarak, kategoriler altında bulunan uygulamaları <strong><em>View Signature</em></strong> kısmı ile görüntüleyebiliriz.</p><p>Not: Eğer uygulamanın hangi kategori altında olduğunu bilmiyorsak, <strong><em>Security Profiles &gt; Application Signature</em></strong> kısmından öğrenebiliriz.</p><blockquote><strong>Network Protocol Enforcement:</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*ECeuHkdX_42-SuoPpSGbtg.png" /></figure><p>Bu kısım, bilinen bağlantı noktalarında (örneğin HTTP [80]) ağ hizmetlerini yapılandırmamıza olanak tanır.<br>Örneğin, HTTP (80) üzerinden gerçekleşen işlemleri izlemek istiyoruz. Bunun için aşağıdaki görselde gözüken ayarları uygulamamız gerekir:</p><p>Port: 80<br>Enforce Protocols: HTTP<br>Violation Action: Monitor</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*buPR9i9h1hYraTMQn5duHg.png" /></figure><blockquote><strong>Application and Filter Overrides:</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*xUbAnoLUVbuHfM29QS7f0Q.png" /></figure><p>Bu kısım, kategori bazında değil de uygulama bazında yapılandırma yapmamızı sağlar.</p><p><strong>Örnek:</strong><br>Biz Video/Audio kategorisini “<strong><em>Block</em></strong>” durumuna getirdik, ancak kullanıcıların YouTube uygulamasına girebilmesini istiyoruz.</p><p>Bu durumda, <strong><em>Application and Filter Overrides </em></strong>kısmını kullanmamız gerekiyor.<br><strong><em>+Create New</em></strong> butonuna tıklayarak aşağıdaki sayfaya erişiyoruz.</p><p>Sonrasında, ‘YouTube’ aratarak üzerine çift tıklıyoruz.<br>Son olarak, Action kısmını “<strong><em>Monitor</em></strong>” olarak ayarlayıp <strong><em>OK</em></strong> tuşuna basıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*ho6FLF831BTM38vf5IbuAw.png" /></figure><blockquote><strong>Options:</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*PRAp-5Ldsc0-Bo-wd5erog.png" /></figure><p>Bu kısımda, <strong><em>QUIC</em></strong> haricindeki ayarları isminden anlayabiliyoruz. QUIC kısmı ise QUIC Protokolü işlemlerine izin verilip verilmeyeceğini ayarladığımız bölümdür.</p><p><strong><em>Peki nedir bu QUIC Protokolü?</em></strong></p><p>QUIC, tam adı “<strong><em>Quick UDP Internet Connections</em></strong>” olan, Google tarafından geliştirilen deneysel bir aktarım katmanı ağ protokolüdür.<br>Temel olarak, TCP ve UDP protokollerinin iyi yönlerinin birleştirilmiş halidir.</p><p>Genellikle istemcilerin web filtreleme gibi UTM özelliklerinin yalnızca Google Chrome’da düzgün çalışmayabileceği, ancak Internet Explorer veya Mozilla Firefox gibi diğer tarayıcılarda mükemmel şekilde çalıştığı saydam proxy’leri atlamasına olanak tanır.</p><p>Yukarıda anlattığımız kısımları kendi ihtiyaçlarımıza göre ayarladıktan sonra, OK tuşuna basmamız <strong><em>Application Control</em></strong>’ü oluşturmamızı sağlar.<br>Sonrasında, bu <strong><em>Application Control</em></strong>’ü aktif etmek için kurallarımıza eklememiz gerekmektedir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JfUlE2K8DvvnsprqgstURg.png" /></figure><p>WARNING..!<br>Yazımızın Sonuna Gelmiş Bulunmaktayız ..! :)<br>Umarım sizlere yardımım dokunmuştur. Bir sonraki yazımda buluşmak dileğiyle ..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e05bff1118a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fortigate’te Web Filter]]></title>
            <link>https://medium.com/@yunuscakici.08/fortigatete-web-filter-636c7f12aadf?source=rss-4d6270a329d7------2</link>
            <guid isPermaLink="false">https://medium.com/p/636c7f12aadf</guid>
            <category><![CDATA[fortinet]]></category>
            <category><![CDATA[fortigate]]></category>
            <category><![CDATA[fortinet-firewall]]></category>
            <category><![CDATA[web-filtering]]></category>
            <category><![CDATA[web-filter]]></category>
            <dc:creator><![CDATA[Yunus Emre Çakıcı]]></dc:creator>
            <pubDate>Sat, 23 Nov 2024 10:32:41 GMT</pubDate>
            <atom:updated>2024-11-23T10:33:38.568Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*DD8yX7DhI6AUkPvWgfAcWw.png" /></figure><h4>Web Filter Nedir?</h4><p>Fortigate Firewall tarafında, kullanıcıların hangi sitelere girebileceğini veya giremeyeceğini belirlediğimiz kısım <strong>Web Filter</strong> bölümüdür. Burada oluşturduğumuz filtreleri kurallarımıza ekleyerek, kullanıcıların web üzerinden yaptıkları gezintileri kontrol altında tutabiliriz.</p><h4>Web Filter Nasıl Oluşturulur?</h4><p>Öncelikle <strong>Security Profiles &gt; Web Filter</strong> sekmesine giriyoruz.<br>Sonrasında sol üst taraftaki <strong>+Create New</strong> butonuna tıklayarak aşağıdaki sayfaya erişiyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V-2kimtrTjLLHo4g1ZOIOA.png" /></figure><p>Şimdi gelin burayı biraz inceleyelim:</p><blockquote><strong><em>FortiGuard Category Based Filter:</em></strong></blockquote><p>FortiGuard tarafından analiz edilip kategorilere ayrılmış web siteleri için filtre uyguladığımız alandır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*H1rIcJn8RFy7a0Y7BwPVGA.png" /></figure><p>Yukarıdaki resimde de görüldüğü gibi 5 adet <strong>izin türü</strong> vardır:</p><ul><li><strong>Allow</strong>: Erişim izni verir.</li><li><strong>Monitor</strong>: Erişim izni verir ve <em>Allow</em>’dan farklı olarak tüm logları tutar.</li><li><strong>Block</strong>: Erişimi engeller.</li><li><strong>Warning</strong>: Siteye giriş esnasında kullanıcıya uyarı verir. Kullanıcı isterse siteye girer, istemezse siteden ayrılır.</li><li><strong>Authenticate</strong>: Kullanıcı, siteye erişmeden önce Fortigate ile kimlik doğrulamasından geçer.</li></ul><p><strong>FortiGuard’ın sunduğu kategoriler</strong>, resimde de görüldüğü gibi 8 ayrı kategori bulunmaktadır. Bunların içinden en önemlileri şunlardır:</p><ul><li><strong>Potentially Liable</strong></li><li><strong>Adult/Mature Content</strong></li><li><strong>Security Risk</strong></li></ul><p>Bu kategorileri her zaman <em>Block</em> olarak ayarlamak en iyi yaklaşımdır.</p><p><strong>Category Usage Quota:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/392/1*TR1U4fs8CICM6J67eWnwbg.png" /></figure><p>Bu kısım sayesinde <em>Monitor</em> olarak ayarladığımız filtrelere kota kısıtlaması getirebiliriz. Örneğin, <em>Social Networking</em> kısmını <em>Monitor</em> olarak ayarladık ve çalışanlarımızın bu kategori altındaki web sitelerine günde 1 saat girmelerini istiyoruz. Bunun için <strong>+Create New</strong> butonuna tıklayarak aşağıdaki işlemi gerçekleştirebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*X80xnJv-4CCdfxZeWM0AmA.png" /></figure><blockquote><strong><em>Allow Users to Override Blocked Categories:</em></strong></blockquote><p>Bu işlem, adı üstünde, bu filtrenin dışında tutmak istediğimiz kullanıcıları tanımladığımız bölümdür. Örneğin, bir şirketin sosyal medya tarafında çalışan elemanları hariç diğer herkese sosyal medya kategorisini engellemek istiyorsak, sosyal medya çalışanlarının ait olduğu birimi bu filtrenin dışında tutmamızı sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*xO3LpqvCGCGPIcBNKHI7Aw.png" /></figure><blockquote><strong><em>File Filter:</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*vpzOixbkXqehtbA9lmt5Pw.png" /></figure><p>Fortigate’den geçen farklı dosya türlerinin akışını kontrol etmek için kullanılır. Dosya filtreleme, dosya boyutuna veya içeriğine değil, yalnızca dosya türüne dayanır.</p><p>Eğer oluşturmak istersek, aşağıdaki resimde gözüktüğü gibi <strong>File Type</strong> kısmından dosya türünü seçeriz. <strong>Action</strong> kısmından dosyanın akışına izin verip log tutulmasını istersek <em>Log</em>, izin verilmesini istemezsek ise <em>Block</em> kısmını seçeriz. <strong>Direction</strong> kısmında ise filtrenin hangi yönde geçerli olacağını belirleriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*6IsqyiPfkWIt3TrfETh2hw.png" /></figure><blockquote><strong><em>Static URL Filter:</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/443/1*4_3LbJd1MfOgL-Xbfu0omg.png" /></figure><ul><li><strong>Block Invalid URLs</strong>:<br>Bu alanı aktifleştirdiğimizde, SSL sertifikası <em>CN</em> alanı geçerli bir alan adı içermediğinde web sitelerini engeller.</li><li><strong>URL Filter</strong>:<br>Web Filter ile tüm kategorilere engel verebiliyoruz ancak içerisinden sadece belirli web sitelerine izin verebiliyoruz. Bu durumlar için bu kısmı kullanabiliriz.</li></ul><p>Bunun için <strong>URL Filter</strong> kısmını aktifleştirip <strong>+Create New</strong> butonuna tıklıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/651/1*1A94jVlUPEaT6N5X_Y8YCw.png" /></figure><p>Sonrasında, aşağıdaki çıkan sayfada <strong>URL</strong> kısmına Web Filter’ın dışında tutmak istediğimiz URL adresini yazıyoruz.</p><p><strong>Not:</strong> Genelde başına ‘*’ sembolü eklenir. Bunun sebebi tüm subdomainleri işleme katmak istememizdir (Örnek: *.trendyol.com).</p><p>Bu işlemi gerçekleştirebilmek için <strong>Type</strong> kısmı <strong><em>Wildcard</em></strong> olarak seçilmelidir. Çünkü <em>Wildcard</em>, bir web sitesine ait subdomainleri de dahil ederek bir eşleşme sağlar. Yukarıdaki örnekte *.trendyol.com yazarsak, mail.trendyol.com ve odeme.trendyol.com gibi subdomainler de eşleşir.</p><p><strong>Action</strong> kısmını, şu anda Web Filter’ın dışında tutarak izin verdiğimiz bir senaryodan bahsettiğimiz için <em>Monitor</em> seçiyoruz. Ancak tersi bir işlem yapacaksak, örneğin <em>Shopping</em> kısmını <em>Monitor</em> olarak ayarlayıp Trendyol’u engellemek istiyorsak, bu kısmı <em>Block</em> olarak seçmemiz gerekir.</p><p><strong>Status</strong> kısmı, bu URL Filter’ın aktifliğini ayarladığımız bölümdür.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*7o9Eklt4PX9bIAqsxs1KaQ.png" /></figure><ul><li><strong>Block Malicious URLs Discovered by FortiSandbox</strong>:<br>Bu ayar aktif olduğunda, FortiSandbox’ın bulduğu kötü amaçlı URL’leri engeller.</li><li><strong>Content Filter</strong>:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*svoJfNcgsQmvDQlhuFe3Iw.png" /></figure><p>Web siteleri içerisindeki kalıplar, sözcükler, söz öbekleri ve joker karakterler gibi materyalleri içeren web sitelerini engelleyebiliriz.</p><p>Yeni bir <strong>Content Filter</strong> oluşturmak istediğimizde aşağıdaki açılan sekmede:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/792/1*0O_vDTZWLFOeyCXUFYyIbg.png" /></figure><ul><li><strong>Pattern Type</strong>: <strong><em>Wildcard</em></strong> seçersek forti*.com joker karakter ifadesi, fortinet.com ve fortiguard.com ile eşleşir. Ancak <strong><em>RegularExpression</em></strong> seçersek, oradaki *, sembolden önceki karakteri temsil eder. Yani fortiiii.com ile eşleşir ancak fortinet.com veya fortiiiguard.com ile eşleşmez.</li><li><strong>Pattern</strong>: Bu örnek üzerinde forti*.com.</li><li><strong>Language</strong>: Kalıpların, sözcüklerin ve diğer materyallerin algılanacağı dil.</li><li><strong>Action</strong>: <em>Block</em> engeller; <em>Exempt</em> ise muaf tutar.</li></ul><blockquote><strong><em>Rating Options:</em></strong></blockquote><p>FortiGuard tarafından derecelendirilmiş web siteleri için seçenekler sunar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*f1M5I5fh_9NTO1lTsrONFg.png" /></figure><ul><li><strong>Allow Websites When a Rating Error Occurs</strong>:<br>FortiGuard lisansınız yoksa ve FortiGuard lisansına ihtiyaç duyan hizmetleri etkinleştirdiyseniz, bir derecelendirme hatası iletisi alırsınız. Bu ayarı aktif ederseniz, derecelendirme hatası döndüren web sitelerine erişime izin verilir.</li><li><strong>Rate URLs by Domain and IP Address</strong>:<br>Bu ayar etkinleştirildiğinde, FortiGate, yalnızca URL alan adını değil, aynı zamanda TCP/IP paketinin IP adresini de FortiGuard’a gönderir.</li></ul><blockquote><strong><em>Proxy Options</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*W6QeepRwb2xim_Sj9XDOuw.png" /></figure><ul><li><strong>Restrict Google Account Usage to Specific Domains</strong>:<br>Sadece belirli Google hesaplarına ve hizmetlerine erişimi kısıtlamak için bu ayarı kullanabilirsiniz.</li><li><strong>Remove Java Applets, ActiveX, and Cookies</strong>:<br>Java uygulamalarını, ActiveX’i ve çerezleri web trafiğinden filtrelemek için bu ayarları kullanabilirsiniz. Ancak, bu filtreler etkinleştirilirse, bu teknolojileri kullanan web sitelerinin düzgün çalışmayabileceğini unutmayın.</li></ul><p>Son olarak OK tuşuna basmamız Web Filter ‘ımızı oluşturmamızı sağlayacaktır. Sonrasında bu Web Filter’ı aktif etmek için Web Filter ’ı eklediğimiz bir kural yazarız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LUzZwPDaypjXJJ1b-x2EdA.png" /></figure><blockquote>WARNING..!<br>Yazımızın Sonuna Gelmiş Bulunmaktayız ..! :)<br>Umarım sizlere yardımım dokunmuştur. Bir sonraki yazımda buluşmak dileğiyle ..</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=636c7f12aadf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>