android'e giriş eğitimleri 2_1
TRANSCRIPT
Android‘e Giriş Eğitimi Dökümanları 2/1
Android Uygulama Geliştirme Ortamının İncelenmesi Bilgi Teknolojisi Eğitim Programları
Bu Çalışma Univerist Materyal geliştirme ekibi tarafından Bilgi Teknolojileri Eğitimleri için derlenmiştir. Dökümanla ilgili kaynaklar makalenin sonunda “Kaynakça” kısmında detaylı bir şekilde belirtilmiştir.
1
1.ANDROİD CİHAZLAR VE ANDROİD İŞLETİM SİSTEMİ ÜZERİNE GENEL
BİLGİLER
Android, Linux çekirdeğini kullanan bir işletim sistemidir. Google, Open Handset Alliance ve özgür
yazılım toplulukları tarafından geliştirilmektedir. Temel olarak dokunmatik ekranlar için tasarlanan
Android, düşük maliyetli ve kişiselleştirilebilen işletim sistemi arayan yüksek teknoloji cihazlar
arasında da popülerdir. Başlarda bu sadece tablet ve akıllı telefonları kapsasa da, günümüzde
televizyonlar, arabalar, oyun konsolları, dijital kameralar ve saatler gibi cihazlarda da kullanılmaya
başlamıştır.
2013 yılı Kasım ayı verilerine göre en popüler mobil işletim sistemi haline gelen Android uygulama
marketi olarak Google Play Store'u kullanmaktadır. 2014 yılı Ekim ayı itibariyle markette 1 milyondan
fazla uygulama, yıllık 50 milyarı aşkın indirme sayısı bulunmaktadır. Google'ın 2014'ün Haziran
ayında verdiğirakamlara göre 1 milyardan fazla aktif Android kullanıcısı bulunmaktadır. 2013'ün
Nisan ayında yapılan birankete göre de yazılım geliştiricilerin %71'inden fazlası Android için
uygulama geliştirmektedir. Google Play Store ile ilgili bilgilere buradan ulaşabilirsiniz.
2007 yılında pek çok yazılım, donanım, telekomünikasyon firmasının katkıda bulunduğu Open
Handset Alliance adı verilen şirketler birliği sayesinde ortaya çıkan Android'in kaynak kodları iki farklı
lisans kullanır. Kullandığı Linux çekirdeği GPL, diğer dış bileşenler ise Apache Lisansı ile
lisanslanmıştır. Bu değiştirilebilir yapı yazılımcıları Android'e katkıda bulunmaları için
cesaretlendirdiğinden sürekli gelişmesini ve yeni özelliklerin eklenmesini sağlar.
Teknik bilgiler
Bu platformda uygulamalar Android Yazılım Geliştirme Kiti (SDK) kullanarak Java dilinde yazılır. Bu
SDK yazılımcıya hata ayıklayıcı, yazılım kütüphaneleri ve emülatör gibi yardımcı araçlar sunar.
Android güç kullanımını en aza indirmek ve hafızayı yeterli kullanabilmek için çeşitli yöntemler
kullanır. Kullanılmayan uygulamaların bekleme moduna alınması; yetersiz hafıza durumunda uzun
süredir aktif olmayan uygulamaların kapatılması bu yöntemlerden bazılarıdır.
İşletim sisteminin donanım olarak içerdiği jiroskop, yakınlık algılayıcı, ivme ölçer gibi fonksiyonlar da
uygulama geliştiriciler için fayda sağlar. Örneğin, telefon yan çevrildiği zaman görüntünün de
dönmesi bu araçlar yardımıyla uygulanabilir.
Android öncelikli olarak 32-bit ARMv7 işlemcilerine yönelik geliştirilmektedir. Bunun yanında Android
x-86projesi x86 işlemcler için de destek sağlar. Google her altı ila dokuz ay arasında yeni bir sürüm
2
yayınlamaya özen gösterir. En yeni sürüm olan Android 4.4 (KitKat)'ün gereksinimleri ise şu
şekildedir:
512 MB RAM,
32-bit ARMv7, MIPS ya da x86 mimarisinde işlemci,
OpenGL ES 2.0 uyumlu bir GPU.
Her üretici kendine özel Android türevini içeren bir ROM çıkartabildiği için için güncellemeler her
model Android işletim sistemli cihaza aynı anda gelmeyebilir. Eylül 2014 itibariyle kullanıcıların
yüzde 24.5'i KitKat'ı kullanırken, yüzde 53.8'i Jelly Bean, geri kalanı ise daha eski sürümleri
kullanıyordu.
En çok kullanılan Android sürümleri aşağıdaki gibidir:
Android 4.0.3–4.0.4 Ice Cream Sandwich (API level 15)
Android 4.3 Jelly Bean (API level 18)
Android 4.4 KitKat (API level 19)
Android L (API level 20)
Android güvenlik açısından da güçlü olmak adına uygulamaların sistemin tüm alanlarına müdahele
etmesini engeller. Her uygulamanın kullanmak istediği alanlar için kullanıcıdan izin alması gerekir.
Mimari
Android mimarisi,
1. Linux çekirdeği
2. Kütüphaneler
3. Android çalışma zamanı (runtime),
4. Uygulama geliştirme çatısı
5. Uygulamalar katmanlarından oluşur.
3
Mimari ve sistem özellikleri hakkındaki eğitime buradan ulaşabilirsiniz.
Kullanım alanı
Daha önce de belirttiğimiz gibi Android kullanımı artık sadece akıllı telefonlar ve tabletlerle sınırlı
değil. Akıllı kitaplar, televizyonlar, kameralar, saatler, kulaklıklar ve daha pek çok teknolojik alet artık
Android platformunu kullanabiliyor. 2011 yılında Google Android@Home adını verdiği ev otomasyon
teknolojisini tanıttı. Bu teknoloji sayesinde ev ortamında bulunan her türlü aydınlatma, priz ve
termostat tarzı cihazlar Android telefonlar ya da tabletlerden yönetilebiliyor. Yine 2011
yılında Parrot şirketi araba içi sistemi için kullanabilen Asteroid sistemini tanıttı. Önümüzdeki yıllarda
Android'in ve diğer mobil işletim sistemlerinin kullanım alanının genişlediğini görmeye devam
edeceğiz gibi görünüyor.
1.1.Google Play
Google tarafından yönetilen Google Play, Android cihazların uygulama ve oyunlara ulaşabileceği
çevrim içi bir markettir. Buradan, çoğu zaman geliştiricilerin tercihleri doğrultusunda ülkelere göre
yayınlanan oyun ve uygulamalara erişilebilir. Android cihazlar üzerinden Google Play uygulamasıyla
ya da Google Play sitesinden erişilebilir.
4
Google Play, üzerinde yer alan uygulamaları kategorilerine göre ayırarak kullanıcılara sunar. Ana
sayfasında en çok satılan ve talep gören uygulamalara yer verir. Ayrıca "Editörün Seçimi" gibi yeni
bir kategorilendirmeye daha da gitmiştir. Yukarıdaki resimde yer alan arama kutusuna ilgilendiğimiz
bir konuyu ya da geliştirici firma adını girerek kolayca arama yapabiliriz. Bir uygulamayı seçtiğimizde
aşağıdaki uygulama detay sayfasına yönlendiriliriz.
Bir uygulamanın ayrıntı sayfasına girdiğimizde, uygulamanın adını, hemen altında geliştiricisini
görürüz.Yükle düğmesine tıkladığımızda uygulama Google hesabımıza bağlı Android cihazlarımıza
gönderilir.
5
Uygulama detay sayfasında aşağı doğru ilerlediğimizde, uygulama içi görselleri bulabiliriz.
Görsellerin hemen altında geliştirici tarafından yapılan açıklamalara ve uygulamayı indiren
kullanıcıların yorumlarını görme şansımız var. Kullanıcılar çok çeşitli amaçlarla da yorumlar
yapabilirler.
Detay sayfasında daha aşağıya indiğimizde uygulamaya dair ek bilgiler karşımıza çıkar. Burada
uygulamanın hangi sürümde olduğu, boyutu ve hedef Android sürümleri görülebilir. Burada yer alan
geliştirici bağlantı sayfaları ise, geliştiriciye ulaşabilmeniz açısından, geliştirici tarafından paylaşılan
sayfalardır. Sayfanın sonunda ise benzer uygulamalar ve bu geliştiricinin diğer uygulamalarına da
bakabilirsiniz.
6
1.2.Android Mimarisi ve Sistem Özellikleri
Android, Open Handset Alliance, Google ve özgür yazılım topluluğu tarafından geliştirilen bir mobil
işletim sistemidir. Bu işletim sisteminin parçaları çekirdek (kernel), sistem kütüphaneleri, uygulama
geliştirme çatıları (frameworks) ve yerleşik temel uygulamalardan oluşmaktadır. Android mimarisi
aşağıdaki gibidir.
Bu yapıyı ayrı ayrı incelemek geliştirici adaylarının üzerinde çalıştıkları yapıyı anlamaları
bakımından faydalı olacak.
Temel yapı (Linux çekirdeği)
Android, Linux çekirdeğini (kernel) kullanır. Linux çekirdeğine Android için eklenen kod parçacıkları
ve kütüphaneler Genel Kamu Lisansı'na sahipken, diğer bileşenler üretici firmalarına kendi kapalı
ROM'larını oluşturmalarına izin verecek ama yine özgür bir şekilde Apache Lisansı ile
dağıtılmaktadır.
Linux çekirdeğinin doğrudan kaynak sağladığı yapılar security (güvenlik), memory ve
process (hafıza ve süreç) kontrolü, dosyalama ve bağlantı için I/O işlemleri ve cihaz sürücüleridir.
Çekirdekte Android için özelleştirilmiş başlıca alanlar ise güç kontrolü, paylaşılan hafıza, low
memory killer ve süreçler arası iletişim içindir.
7
Kütüphaneler (Libraries)
Mimarinin diğer önemli yapısı olan kütüphaneler bölümünde C ile yazılmış sistem kütüphaneleri,
internet tarayıcısı (browser) motorlarının çalışması için Webkit, görüntüleme kontrolünü
yapan Surface Manager, grafik işlemleri için OpenGL, ses ve video işlemleri için gereken Media
Framework, veri yapıları kontrolü ve düzenlenmesi için SQLite gibi yapılar bulunur.
Android Runtime
Bu bölüm Linux çekirdeğindeki kütüphanelerin Java ile birleştiği bölümdür. İki önemli bileşeni vardır.
Bunlar temel Java kütüphaneleri ve Dalvik Sanal (virtual) Makinesi'dır. Bu yapılar hakkında detaylı
bilgileri ilerleyen eğitim içeriklerinde bulacaksınız. Burada Dalvik Sanal Makinesi'ne kısaca
değinelim:
Dalvik Sanal Makinası: Uygulamalar Dalvik Sanal Makinesi tarafından çalıştırılır. Temel çalışma
mekanizmasını anlamak Android projelerinin yaşam döngüsünü anlamak açısından önemlidir. Java
ile yazılan uygulamalar alınır, Java kodları derlenerek bytecode dosyalarına çevrilir. Bu dosyalar
dex dosyasına çevrilerek Dalvik Sanal Makinesi'nin çalıştıracağı şekle sokar. Dalvik ortamı düşük
işlemci gücü, az RAM ve sınırlı batarya koşullarına göre tasarlanmıştır.
Not: Dalvik her ne kadar mobil odaklı ve kısıtlı kaynaklarla çalışabilecek bir yapı olsa da, bazı
alanlarda iyileştirilmesi gereken ve zamanın şartlarına göre tasarlanmış, artık yavaş yavaş eskiyen
bir runtime. Google bunun farkında olduğu için yaklaşık 2 yıldır yeni bir runtime üzerinde çalışıyor,
ismi ART yani Android Runtime. Dalvik'ten çok farklı bir bir çalışma yapısına sahip olan ART
hakkında ayrıntılı bir blog yazısına buradan ulaşabilirsiniz.
Eğitimin ilerleyen bölümlerinde uygulama çatılarını (application framework) adım adım anlatacağız.
Şimdiden herkese bu yeni dünyada başarılar diliyoruz :).
8
2.ANDROİD İÇİN GELİŞTİRME ORTAMININ KURULMASI
Bir önceki bölümde öğrendiğimiz Java bilgisiyle,eğitime içeriklerine devam ediyoruz. Bu bölümde
Android uygulama geliştirmenin temellerini öğreneceğiz.
Android uygulamalarınızı geliştirmek için özel hazırlanmış bir tümleşik geliştirme ortamı (Integrated
Development Environment) olan Android Studio'yu artık kullanabilirsiniz. Tümleşik geliştirme
ortamlarıyla kolayca proje oluşturabilir, kod yazarken yardım alabilir, renklendirilmiş kodlarla
kodunuza daha kolay hâkim olabilir, hata durumlarını önceden fark edebilirsiniz.
Android Uygulamaları Geliştirmek İçin Android Studio
Bu bölümden sonra Android uygulaması geliştirmek için Google tarafından resmi olarak duyurulan
Android Studio'yu kullanacağız. Android Studio, uygulama yazarken işinizi kolaylaştıran araçlara
sahip. Bu araçların nasıl kullanılacağı ve ne işe yaradıkları hakkında eğitimleri kurulum
belgelerinden sonra göreceğiz.
Sıradaki eğitim içeriklerinde Android Studio'yu (IDE) Windows, Mac OS X ve Linux ortamlarında
nasıl kurabileceğinizi görebilirsiniz.
İyi kodlamalar!
2.1.Android Studio'nun Windows Üzerinde Kurulumu
Google, Android Studio 1.1'i yayınladı. Bu eğitim içeriğinde bu IDE'yi hep beraber kuracağız.
Öncelikle buradaki indirme sayfasına gidiyoruz:
9
Yeşil bölgede yer alan "Download Android Studio for Windows" düğmesine tıklıyoruz. İndirme işlemi
tamamlandıktan sonra dosyamıza çift tıklıyoruz. Windows öncelikle bizden cihaz üzerinde kurulu
yönetimsel izinleri isteyecektir. Burada yönetici şifresini girerek devam edebilirsiniz.
Yönetici izni verildikten sonra, Android Studio kurulumu için ilk adım görülmektedir. Next düğmesine
basılır.
10
Next düğmesi sonrası karşımıza çıkacak ekranda yüklemek istediğimiz bileşenleri seçiyoruz ve
tekrar Next tuşuna basıyoruz.
Next düğmesine bastıktan sonra lisans sözleşmesi karşımıza gelecek. Sözleşmeyi okuduktan sonra
eğer kabul ediyorsak "I Agree" düğmesine basmamız gerekiyor.
11
Sözleşmeyi onayladıktan sonra karşımıza Android Studio'nun ve SDK'nın nereye yükleneceğini
soran bir pencere gelecek. Uygun yerleri belirttikten sonra tekrar "Next" düğmesine basıyoruz.
Gerekli dosyaların bilgisayarınıza kopyalanması biraz süre alabilir. Tamamlandıktan sonra karşınıza
gelecek ekrandan "Finish" düğmesine basarak yükleme işlemini başarıyla bitirebilirsiniz.
12
Artık Android Studio'yu kullanmak için hazırsınız. Yazacağınız uygulamaları bekliyoruz!
2.2.Android Studio'nun Mac OS X Üzerinde Kurulumu
Google, Android Studio 1.1'i yayınladı. Bu eğitim içeriğinde bu IDE'nin kurulumunu öğreneceksiniz.
Öncelikle buradaki indirme sayfasına gidiyoruz:
13
Eğer bilgisayarınızda JDK'nın 7'den yukarı sürümü yoksa buradan nasıl kurulacağını
öğrenebilirsiniz.
JDK'yı yükledikten sonra Android Studio yükleme ekranına geri dönüp "Detect" düğmesine basın.
Android Studio biraz önce yüklediğiniz JDK'nın yerini kendi bulup tanımlayacaktır.
14
JDK yolunu tanımladıktan sonra yükleme işlemine devam edin. Sıra SDK ve Virtual Device
yüklemelerine geldi. Aşağıdaki ekranda yüklenmesini istediğiniz SDK ve Virtual Device'i seçin. Bir
uygulama geliştirmek için varsayılan olarak gelen Android SDK ve Android Virtual Device sizin için
yeterli olacaktır. SDK'lar hakkında daha fazla bilgiyi buradan alabilirsiniz.
Gerekli SDK ve Virtual Device seçiminden sonra sıra bunların lisans sözleşmelerini imzalamaya
geldi. Aşağıdaki ekrandan bütün lisanslar için "Accept" seçeneğine bastıktan sonra "Finish" diyerek
yükleme işlemini başlatabilirsiniz.
15
Aşağıdaki gibi bir ekranı gördüyseniz yüklemeniz tamamlanmış demektir.
Tekrar "Finish" düğmesine bastığınızda artık uygulamayı Mac'inizin "Uygulamalar" kısmına
sürükleyip bırakmaktan başka bir göreviniz kalmamış demektir. Aşağıdaki ekrandan "Android
Studio" simgesini "Uygulamalar" simgesine sürükleyip bırakın. Tebrikler!
16
2.3.Android Studio'nun Linux Üzerinde Kurulumu
Bu eğitim içeriğinde Android Studio'nun Linux üzerinde kurulumunu öğrenebilirsiniz.
UYARI: Android Studio'yu çalıştırabilmek için bilgisayarınızda Java Development Kit'i (JDK) kurmuş
olmalısınız. Linux için JDK kurulumunu nasıl yapacağınızı bu belgeden öğrenebilirsiniz.
Öncelikle https://developer.android.com/sdk/index.html adresine girip "Download Android Studio"
düğmesine tıklayın:
Tıklayınca yönlendirildiğiniz sayfayı biraz aşağı kaydırıp "All Android Studio Packages" bölümüne
gelin. Burada hem Android Studio'yu hem de Android SDK'yı indirebileceğiniz paketler bulunuyor.
17
Linux için en alttaki zip dosyasını indirmeniz gerekiyor. Tıklayın. Şöyle bir anlaşma metni karşınıza
çıkacaktır:
Anlaşma şartlarını onayladığınızı belirten seçeneği işaretledikten sonra en alttaki Download
düğmesine basın. Yaklaşık 240 MB'lık bir dosya inmeye başlayacaktır:
İnen ZIP dosyasını ayıklamanız gerekecektir:
18
ZIP dosyasını ayıkladıktan sonra "android-studio" isimli dizini görüyor olmalısınız. Bu dizine girin ve
ardından içindeki /bin dizinine girin. /bin dizininin içeriği şöyledir:
Buradaki studio.sh dosyasını çift tıklayarak Android Studio'yu çalıştırabilirsiniz:
19
3.ANDROİD STUDİO'YU TANIYALIM
Android Studio, Android uygulamalarının geliştirildiği, üst seviye özelliklere sahip ve Google
tarafından da önerilen resmi programlama aracıdır.
Android Studio'nun kod geliştiricilere sunduğu temel özellikler şunlardır:
Gradle tabanlı, esnek proje inşa sistemi.
Farklı özellik ve sürümlere göre çoklu APK çıktısı.
Temel proje şablonlarıyla hızlı ve kolay proje üretimi.
Ekran tasarımlarını kolaylaştıran sürükle-bırak özellikli zengin editör.
Uygulamanın performansı, kullanılabilirliği, farklı sürümlerde çalışabilirliğinin kontrol edilebileceği
test araçları.
Kolay ve güvenli APK imzalanması.
Ek uğraşa gerek kalmadan Google hizmetlerini uygulamaya ekleyebilme.
Sıradaki eğitim belgelerinde ekran tasarımlarının yapıldığı zengin editörü, yeni bir proje oluşturma
ve önceden farklı bir IDE kullanarak oluşturduğunuz projenizi Android Studio'ya nasıl taşıyacağınızı
göreceksiniz.
3.1.Android Studio Layout Editörü
Android Studio'nun en güzel özeliklerinden biri de ekran tasarımlarını sürükle&bırak yöntemiyle
kolayca hazırlayabilmenize fırsat vermesidir. Ekran tasarımlarını yapacağınız "Layout Editor"
sürükle bırak yöntemiyle ekrana taşıyacağınız bileşenlerle ilgili yaptığınız değişiklikleri de anlık
olarak gösterir.
Tasarladığınız Activity veya Fragment'ların yerleşim (layout) XML'lerini proje ağacında
/res/layoutklasöründe görebilirsiniz. Örnek bir projenin dizin yapısı aşağıdadır:
layout dizininden istediğiniz ekranı açarak ekran bileşenlerini sürükle bırakla tasarlayabilirsiniz.
20
Bileşenlerle ilgili "Properties" bölümünde yaptığınız değişiklikleri anlık olarak ortadaki bölmede
görebiliyorsunuz.
Alttaki Text sekmesine tıkladığınızda, ekranın tasarımını XML şeklinde göreceksiniz. Yine burada
yaptığınız güncellemeleri anında yan ekrandan izleyebileceksiniz.
Şimdiden iyi kullanımlar.
21
3.2.Eclipse Projesinin Android Studio'ya Taşınması
Daha önce Eclipse'te geliştirdiğiniz projeleri Android Studio'ya taşımak isteyebilirsiniz. 1.0 sürümü
öncesinde bunun için projeyi Eclipse ile açıp Gradle uyumlu hale getirmekle uğraşıyorduk. Android
Studio'nun yeni sürümünde bu tür Android Studio projesi olmayan (Non-Android Studio project)
projeleri Android Studio ile kullanmak çok daha kolay. "Import Non-Android Studio Project"
düğmesini kullanıp, açılan ekranda projenizi seçip tercihlerinizi belirleterek işlemi yapabiliyorsunuz.
Eclipse gibi farklı IDE'ler üzerinde yaptığımız projemizin dizinini seçiyoruz:
22
23
Eğer projenizin bağımlı olduğu başka kütüphaneler varsa ve onların da Gradle ile uyumlu olmasını
istiyorsanız ilgili seçenekleri seçiniz:
NOT: Eclipse'te proje olarak kullandığımız yapılar, Android Studio'da modül olarak isimlendiriliyor.
Örneğin bir uygulamanız var ve akıllı saatler için bir sürüm, telefon ve tabletler için ayrı bir sürüm
yapıyorsunuz. Bu durum da akıllı saatlerle ilgili bölümünü bir modül, telefon ve tabletlerle ilgili
bölümünü de bir modül olarak Android Studio projenizde oluşturup ayrı ayrı derlenmelerini
sağlayabilirsiniz.
Son olarak Finish düğmesine bastığınızda artık projeniz Android Studio ile çalışmaya uyumlu hale
gelecektir.
24
3.3.Projeye Kütüphane Eklemek
Android Studio'da bir projeye kütüphane eklemenin iki yolu var: Gradle inşa sisteminin kullandığı
build.gradle dosyasına doğrudan kütüphanenin eşsiz bir kimliğini (artifactID) yazmak veya projenin
"Dependency" yani bağımlılık ekleme sihirbazını kullanarak bu yazma işlemini IDE'nin bizim
yerimize yapmasını sağlamak. İkinci işlem biraz daha uzun olanı.
İlk olarak uzun yoldan aratma ile eklemeyi görelim.
Uygulamamızda Facebook Android SDK’yı kullanacağımızı varsayalım.
Öncelikle File > Project Structure yolunu takip ediyoruz:
Açılan pencereden projemizdeki modül ismine (örneğimizde "app") ve ardından da "Dependencies"
sekmesine tıklıyoruz.
25
Hemen sağ üstte görülen + düğmesine basıp Library Dependency öğesini seçiyoruz:
Çıkan pencerede varsayılan olarak en çok kullanılan kütüphanelerin listesini görüyorsunuz.
Facebook Android SDK'yı eklemek için üstteki kutucuğa "facebook" yazıp arama düğmesine basın:
Gördüğünüz gibi içinde facebook geçen ve Maven merkezi depoya kayıtlı yazılımlar listeleniyor.
İhtiyacımıza uygun facebook-android-sdk'yı seçiyoruz:
26
OK düğmesine bastıktan sonra Facebook Android SDK'sı projemizin build.gradle dosyasına
eklenecektir. Bir diğer deyişle, projemiz Gradle sayesinde Facebook Android SDK'sını indirecek ve
kullanıma hazır bulacak.
Şimdi diğer yolu anlatalım:
Build.gradle dosyasına dependencies kısmına
compile 'com.facebook.android:facebook-android-sdk:3.22.0' eklemeniz yeterli.
27
Konu hakkında daha fazla örnek ve tavsiye için bu yazıda da bizlere yardımcı olan mezunlarımızdan
Kurtuluş Ahmet Temel'in blog yazısını okumanızı tavsiye ederiz.
4.ANDROİD PROJESİ OLUŞTURMAK
Detaylı Anlatım
Android eklentileri yüklendikten sonra artık yeni bir Android projesi oluşturabiliriz. Bunun için File >
New > Other seçeneği ile çıkan listeden Android Application Project seçeneğini seçiyoruz.
Bir sonraki ekranda projemizle ilgili çeşitli özellikleri girmemiz gerekecek. Buradaki seçeneklere göz
atacak olursak;
Application Name : Uygulamanın adı. Cihazda uygulama adı olarak bu değer görünür.
Project Name : Projenin adı. Bllekte proje dosyaları bu klasör altında görünür.
Package Name : Uygulamanın dosyalarının saklanacağı paket adı. Bu uygulamaya özgü benzersiz
bir ad olmalıdır. Aynı zamanda Google Play hesabında uygulamanızı tanımlayacağından oldukça
önemlidir.
28
Build SDK : Projenin derleneceği Android versiyonunu belirtir.
Minimum Required SDK : Projenin çalışacağı en alt Android işletim sistemi versiyonunu belirtir.
Next düğmesine bastıktan sonra sizi aşağıdaki gibi bir ekran karşılayacaktır. Burada aslında çok
fazla detaya girmeye gerek yok. Varsayılan olarak seçilen seçeneklerin işaretli kalmasında fayda
var:
Create custom launcher icon: Uygulamanızın logosunu belirleyeceksiniz.
Create activity: Uygulamanızın yazımınza başlamadan önce size otomatik olarak bir activity
hazırlayacak.
Mark this project as a library: Projeyi kütüphane olarka belirle.
Create Project in Workspace: Projenizi mevcut çalışma alanınızda açar.
Working Sets: Projenizi çalışma alanlarına ekleyebilirsiniz.
29
Next düğmesine basarak bir sonraki adıma geçtiğimizde uygulamanın simgeleriyle ilgili seçenekler
gelecektir. Burada simgeyi bir imaj dosyasından yükleyebileceğimiz gibi Text seçeneği ile kendimiz
de oluşturabiliriz. Buradaki diğer seçenekler;
Trim Surrounding Blank Space: Yazılı metinle çerçeve arasındaki boşluğu ayarlamanızı sağlar.
Foreground Scaling: Metnin yerleştirileceği bölgeyi belirler.
Shape: Burada simgeyi daire ya da kare olarak tanımlayabilirsiniz.
Background Color: İkonun arka plan rengini belirler.
Foreground Color: İkonun metin rengini belirler.
30
Burada gerekli ayarları yaptıktan sonra Next düğmesiyle bir sonraki aşamaya geçelim. Bu aşamada
bizden uygulamanın tasarımıyla ilgili bilgiler istenecektir. Tabletleri hedefleyen bir uygulamanız
varsa MasterDetailFlow tipini seçmenizi tavsiye ederiz. Bu şekilde tablet cihazlarda solda bir
navigasyon menüsü görüntülenirken akıllı telefonlarda normal uygulama görüntülenir.
31
Bir sonraki ekranda oluşturulacak ekran için detay bilgiler sorulacaktır. Buradaki seçenekleriniz
aşağıdaki gibidir.
Activity Name : Ekranın adı
Layout Name : Ekrana dair tasarımı içeren dosyanın adı
Navigation Type : Uygulamanın ekranlar arası navigasyonuna dair bilgiler içerir. Android 4.0 öncesi
için burada bir seçim yapamazsınız. Tabs seçeneği, ekranın altında diğer ekranlara geçiş için
düğmeler ekleyecektir. Dropdown seçeneği yukarıdan bir menü açacaktır. Swipe Views seçeneği
ekranlar arasında sağa sola kayarak geçişi sağlayacaktır. Tabs and Swipe ise hem aşağıda
düğmeler hem de sağa sola kayarak geçişi kolaylaştırır.
Hierarchical Parent : Temel ekranı seçmenizi sağlar. Uygulamanın ilk açıldığı ekran bu olacaktır.
Title : Oluşturulan ekrana dair başlığı belirtir. Bu ekranın tepesinde yer alır.
32
Burada Finish düğmesine tıklayarak proje oluşturma sihirbazını tamamlıyoruz. Projemiz Eclipse’in
sol menüsünde görüntülenecektir.
Şimdi projenin üzerine sağ tuşla tıklayarak çıkan menüde Run As > Android
Application seçeneğini tıklayalım.
Bu noktadan sonra uygulamayı çalıştırmaya uygun bir sanal cihaz harekete geçecek ve
uygulamamız başlayacaktır. Proje sihirbazında belirttiğimiz gibi MainActivity adındaki ilk ekranda
bir Hello World yazısı göreceğiz:
33
4.1.Bir Android Projesinin Yapısı
Android Studio'nun çıkmasıyla beraber alıştığımız Eclipse düzeni proje yapısı da bazı değişikliklere
uğradı ve daha sadeleşti. Bildiğiniz gibi, yeni bir Android projesi yarattığımızda standart bir Java
projesinden farklı olarak birtakım yeni klasör ve XML dosyaları görürüz. Şimdi bir Android Studio
projesinin yapısını detaylı inceleyelim:
34
build klasörü: Belirli derleme değişkenlerine göre derleme dosyalarını içerir. Ana uygulama modülü
içinde bulunur.
libs klasörü: Eğer uygulamamızda Android SDK içinde yer almayan bir Java kütüphanesi (örneğin
AdMob) kullanıyorsak, ilgili JAR dosyalarını bu klasöre atmamız gerekir. JAR dosyası ekledikten
sonra dosyaya sağ tuşla tıklayıp Add To Build Path seçeneğini seçmeyi unutmamalıyız. Aksi
takdirde derleyici jar dosyasını göremez.
src klasörü: Kaynak dosyaları burada yer alır. Bu klasörün içinde Java dosyalarını tutacağız.
src/androidTest klasörü: Araçlı test belgelerini içerir.
src/main/java klasörü: Uygulama aktiviteleri için Java kaynak kodlarını içerir.
src/main/jni/ klasörü: Java Native Interface (JNI) kullanan yerli kodları içerir.
src/main/gen/ klasörü: R.Java ya da AIDL dosyalarından üretilmiş arayüz belgeleri gibi Android
Studio tarafından yaratılan belgeleri içerir.
src/main/assets/ klasörü: Genelde boştur. raw değerli dosyalarınızı barındırmak için
kullanabilirsiniz. Buraya koyduğunuz dosyalar, .apk dosyasının içine derlenir.
src/main/res klasörü: Uygulamayla ilgili her türlü kaynak bu klasörde tutulur. Burada tutulan dosya
tipleri resim dosyaları, ekran tasarımları ve metin dosyaları olabilir. Şimdi bu klasörü biraz daha
detaylı inceleyelim:
o drawable klasörleri: Bu klasörler uygulamada kullanılan resim dosyalarını içerir. Bu dosyalar PNG
ya da JPEG formatında olabilir. Klasörün yanındaki hdpi (high dpi), ldpi (low dpi), mdpi (medium dpi)
vexhpi (extra hight dpi) cihaza özel ekran çözünürlüklerine göre dosya çağırmamızı sağlar. Örneğin
uygulamanın çalıştığı cihaz eski modelse ve ekranı düşük çözünürlük destekliyorsa ldpi klasörü
içindeki resim dosyaları kullanılacaktır. Ama uygulama yeni nesil geniş ekran bir cihazda çalışıyorsa
ona uygun olarak yüksek çözünürlüklü bir klasörde bulunan dosyalar kullanılır. Eğer uygulamanızda
düzgün bir tasarım varsa ve geniş yelpazede cihazlar destekliyorsanız tasarımcınızdan uygun
formatlarda dosyalar istemenizi öneririz.
o anim klasörü: Animasyon objeleri için derlenen XML dosyalarını içerir.
o color klasörü: Renkleri tanımlayan XML dosyalarını içerir.
o mipmap klasörü: Uygulamanızın açılış logolarını içerir.
o layout klasörü: Burada ekranlara dair tasarım dosyaları bulunur. xml formatındaki bu dosyalar her
ekrana ait tasarımları barındırır. Bir ekran Activity ile oluşturulduğunda onCreate metodu içinde ilgili
layout çağırılır ve ekranda yer alacak öğeler oluşturulur.
o raw klasörü: İsteğe bağlı raw değerli dosyaları içerir. MP3 ve Ogg gibi medya dosyalarını
kaydetmek için uygun bir klasördür.
o menü klasörü: Eğer bir ekranda cihazın Menü tuşuna basıldığında bir menü çıkmasını istiyorsak,
menü elemanlarını bir xml dosyasında tanımlayarak bu klasör içine saklarız.
35
o values klasörü: Uygulamada kullanılan sabit değişkenler burada saklanabilir. strings.xml dosyası
uygulamada kullanılan ve ekranlarda kullanıcıya gösterilen her türlü metni saklar. Anahtar – veri
mantığıyla saklanan bu değerler kod içinde ya da layout dosyalarında çağırılır. Aynı zamanda bu
değerler R.java dosyasında işaretlenir. Bunun dışında colors.xml dosyası layout dosyalarında
kullanılacak önceden tanımlanmış renkleri içerir. styles.xml dosyası ise ekranlarda kullanılan ve
yinelayout dosyalarından çağrılan stilleri içerir. values klasörünün bir başka özelliği de cihazın
ayarlanmış ana diline göre yerelleşebilmesidir. Bunu ilerleyen bölümlerde anlatacağız.
o xml klasörü: aPreferenceScreen, AppWidgetProviderInfo, or Searchability Metadata gibi değerleri
tanımlayan çok yönlü XML dosyalarını saklar.
.gitignore dosyası: git tarafından reddedilen kayıt dışı dosyaları tanımlar.
app.iml dosyası: IntelliJ IDEA modülü.
build.gradle dosyası: Derleme sistemi için değiştirilebilir özellikleri içerir.
AndroidManifest.xml dosyası: Bu dosya uygulamanın kalbidir. Uygulamayla ilgili her türlü özellik
ve uygulamanın işletim sisteminden talep edeceği bütün izinler burada tanımlanır. Aynı zamanda
uygulama içinde kullanılan her ekran burada kaydedilip tanımlanmak zorundadır. Bu özellikleri de
ilerleyen bölümlerde anlatacağız.
4.2.Eclipse Ortamına Proje Eklemek
Önceden çalıştığınız bir projeyi başka bir bilgisayardaki Eclipse içerisinde çalıştırmak ya da Android
201, 301 ve 401 eğitimlerinde sizlerle paylaştığımız örnek projeler üzerinde çalışmak istiyorsanız,
proje dosyalarını Eclipse çalışma ortamına (Workspace) tanıtmalısınız.
ADT'yi açın ve aşağıdaki gibi bir çalışma ortamı (workspace) tanımlayın (Workspace yerine
istediğinizi yazabilirsiniz. Yeni bir çalışma ortamı yaratmak içinse, basitçe burada yer alan
"/workspace" adını silin ve istediğiniz adı yazın):
36
Eğer yukarıdaki ekran görüntüsünde görüldüğü gibi ilk kullanımda "Use this as the default and do
not ask again" seçeneğini işaretlerseniz, ADT her açıldığında artık size workspace sormayacak ve
varsayılan olarak bu alanı açacaktır. Bunu değiştirmek içinse aşağıdaki ekran görüntüsündeki
adımları kullanabilirsiniz:
Karşınıza gelen boş Eclipse ortamında File > Import yolunu takip edin. Çalışma ortamına
bulunmasını istediğiniz proje dosyalarını, karşınıza gelen sihirbazda Existing Projects into
Workspace seçeneğini işaretleyerek ekleyin ve bir sonraki sayfaya geçin:
37
Bu ekranda .zip formatında paketlenmiş uygulamaları eklemek için Select archive file: düğmesi ile
bellek üzerinde eklemek istediğiniz projelerin yerini buluyor ve açmak istediğiniz projeyi seçerek
Open düğmesini tıklıyorsunuz. Eğer uygulama paketiniz klasör halindeyse, o zaman Select root
directory: düğmesini kullanmalısınız.
38
Bu aşamadan sonra Finish düğmesine tıklayarak projenizi Eclipse içerisinde görüntüleyebilirsiniz.
Önemli Hatırlatma: Eğer proje bir Eclipse projesiyse ve çalışma ortamına daha önceden
eklenmediyse listede görünecektir.
İpucu:
Eclipse ortamına proje ekledikten sonra işimize en çok yarayacak kısım, Navigator sekmesi bazen
görünmeyebilir. Navigator'u açmak için aşağıdaki yolu izleyebilirsiniz:
4.3.İlk Android Projesinin ADT Üzerinde Oluşturulması
Bu eğitimde Eclipse'in ADT sürümünü kullanarak bir Android projesinin nasıl oluşturulacağından
bahsediyoruz. Eğitime başlamadan önce SDK kurulumunu yapmış olmanız gerekiyor. İlk
uygulamamızın oluşturulmasını adım adım anlatalım.
Öncelikle Eclipse IDE'sinin sol üst kısmında bulunan New simgesine tıklayınız. Karşınıza
çıkacak pencerede Android klasöründen Android Application Project şeklinde seçim yapınız.
Karşınıza çıkan ekrandaki yerleri doldurunuz:
39
Application Name: Kullanıcının uygulamayı göreceği isimdir. Bu örneğimizde "Kitaplık" şeklinde
olacak.
Project Name: Projenin ismi, Eclipse içinde Project Explorer tarafında gösterilen isim.
Package Name: Uygulamanız için paket adı. Bir uygulamanın paket adı başka uygulamalardan
farklı olmalıdır. Bu yönüyle eşsizdir. Genelde organizasyon ismi alan adının tersi şeklinde yazılır. Bu
örneğimizde paket adını "org.tcellgy.android.kitaplik" olarak belirliyoruz.
Minumum Required SDK: Uygulamanızın üzerinde çalışacağı Android sürümünün en düşük API
seviyesinin belirlendiği kısımdır. Desteklediğiniz cihaz sayısını artırmak için seçebileceğiniz en
düşük API seviyesini seçmeniz gerekir. Biz burada başlangıç değerinde bırakıyoruz.
Target SDK: Uygulamanızı test ettiğiniz en yüksek Android API seviyesini belirtir. Android'in yeni
sürümleri çıktıkça bu sürümlerle uygulamanızı test etmelisiniz.
Compile With: Uygulamanızın derleneceği SDK sürümünün seçildiği alan. Varsayılan olarak bu
değer SDK Manager'dan edindiğiniz en son API sürümüyle gelir.
Theme: Uygulama arayüzünün stilinin (temasının) belirlendiği kısım. Olduğu gibi bırakabilirsiniz.
Next tuşu tıklandıktan sonra karşınıza çıkacak proje yapılandırma ayarlarıyla karşılacaksınız.
Buradan seçili gelen ayarları değiştirmeden devam edelim.
40
Bir sonraki ekranda karşınıza gelecek ekran uygulamızın ikonu konusunda size yardım edecek
ekrandır.
Artık uygulamanızın activity şablonunu seçerek ilk uygulamanız için hazır olabilirsiniz.
41
Biz ilk uygulamamızda Blank Activity seçip finish düğmesine tıklıyoruz. Artık ilk Android
uygulamamızı yapmış bulunmaktayız.
42
Burada Eclipse bizim için iki proje oluşturdu. Birisi bizim kitaplık projemiz
diğeri appcompat_v7 projesi. Adı geçen appcompat_v7, bir kütüphane projesidir. Aynı zamanda
"Support Library" ya da "Destekleme Kütüphanesi" olarak anacağımız ve Android'in yeni
sürümlerinde var olan özelliklerini eski Android sürümlerinde de çalıştırmaya yarayan bir kütüphane.
Bizim projemize eklenme nedeniyse şu: ActionBar adını verdiğimiz ve yeni Android sürümlerinde
olan bir özelliği Android API 8 ile çalışan cihazlarda da çalıştırmayı istememiz (proje oluştururken
seçtiğimiz Minimum Required SDK değerini hatırlayın). Bu ek projeyi silmemeniz ve ayrıntılarını
sonraya saklamanızı tavsiye ederiz.
5.ACTIVITY SINIFI
Activity sınıfı tarafından oluşturulan nesneler uygulama içinde kullanılan ekranları temsil ederler.
Kullanıcı yeni bir ekrana geçtiğinde Context.startActivity metoduyla bu ekran başlatılır. Eğer
yeni Activity,AndroidManifest dosyasında tanımlı değilse uygulamamız çökecektir.
1. <activity<br />
2.
androi
d:name=".MainActivity"<br />
3.
androi
d:label="@string/title_activity_main" ><br />
4.
<inte
nt-filter><br />
5.
<action android:name="android.intent.action.MAIN" /><br />
6. <br />
7.
<category android:name="android.intent.category.LAUNCHER"&nbs
p;/><br />
8.
</int
ent-filter><br />
9. </activity>Her
uygulamanın LAUNCHER olarak tanımlı bir Activity sınıfı olmalıdır. Bu şekilde tanımlanmış
43
birActivity, uygulama ilk açıldığında otomatik olarak harekete geçer ve kullanıcının karşısına çıkan
ilk ekran olur.
Activity dosyaları ilk çalıştıklarında onCreate metodu devreye girer. Bu metotta genel olarak
setContentView metodu çalıştırılarak bir layout dosyasından ekran tasarımı yüklenir. Eğer ekran
ilk oluştuğunda tanımlanması gereken başka değişkenler ve aksiyonlar varsa, onlar
da onCreate metodu içinde gerçekleştirilebilirler.
1. @Override<br />
2.
public void onCreate(Bundle savedInstance
State) {<br />
3. <br />
4.
super.onCreate(savedInstanceStat
e);<br />
5.
setContentView(R.layout.activity_m
ain);<br />
6. <br />
7.
new LoadDatabaseTask().ex
ecute((Void) null);<br />
8. }
onCreate dışında bir Activity’nin yaşam döngüsü içerisinde başka metotlar da harekete geçirilir. Bu
metotları sıralarsak;
onCreate : Activity ilk oluşturulduğunda çağırılır. Activity herhangi bir nedenden ötürü yok edilmezse
(bellek ihtiyacı ya da finish metodu) bir daha çalıştırılmaz.
onStart : onCreate metodu çalıştırılıp görsel öğeler oluştuktan sonra çağırılır.
onResume : Activity herhangi bir sebepten dolayı durdurulduysa (başka bir ekrana geçiş) tekrar
ekrana geldiğinde bu metot harekete geçer. Activity çalıştırılmadan önce harekete geçen son
metottur. Bu metottan sonra belirlenen koda göre Activity yaşamına başlar.
onPause : Activity bir sebepten dolayı arka plana atılırsa harekete geçer. Bu Back tuşuna
basılmasından ya da sistemin bellek ihtiyacından kaynaklanabilir. Bu metot içerisinde anlık bilgilerin
kaydedilmesi önerilir. onPause işlemi hızlı çalışmak zorundadır, çünkü buradaki işlem bitmeden bir
sonraki Activity harekete geçmez.
onStop : Activity arka plana atıldığı anda işleme girer. Bu noktada iki seçenek vardır; ya kullanıcı
yeni ekrandaki işini bitirip geri gelir ya da Activity tamamen kapatılır. Kullanıcı geri geldiği
44
takdirdeonRestart metoduna geçilir ve döngü onStart metodundan tekrar başlar. Eğer kullanıcı geri
gelmeyecekse onDestroy metodu çalıştırılır.
onDestroy : Activity’e ait bütün kaynaklar yok edilir. Activity bu noktada yaşam döngüsünü
tamamlamıştır.
Yukarıdaki metotlar bir Activity’nin yaşamını kontrol etmemize yardımcı olur. Özellikle kullanıcı bir
ayarı kaydediyorsa ya da oyun oynuyorsa ve bu sırada bir telefon konuşması başlayacaksa anlık
durumları kaydetmemiz için bu metotların çalışma esaslarını bilmeliyiz.
Herhangi bir ekranın Activity sınıfı tarafından oluşturulması yeterlidir. Ancak bunun yanında Android
işletim sistemi, sık kullanılan ekranlara özel Activity sınıfları sağlar. Bunlara göz atarsak;
ListActivity : Bir veritabanındaki veriyi listelemek ya da sunucudan gelen veriyi kullanıcıya
göstermek, uygulamalarda oldukça sık rastlanan işlemlerdir. Bunun için Android işletim sistemi
bizeListActivity sınıfını sunar. Standart bir layout dosyasından oluşturulan bu ekran sayesinde
elimizdeki veriyi oldukça rahat bir şekilde görüntüleyebiliriz.
MapActivity : Harita uygulamaları için sık kullanılan bir Activity tipidir. Google Maps haritaları
üzerinde işlem yapacağımız bir uygulamamız varsa bu Activity bize yardımcı olacaktır.
PreferenceActivity : Android işletim sistemine benzer bir kullanıcı ayar menüsü yapmayı
hedefliyorsak, PreferenceActivity’den faydalanabiliriz. PreferenceActivity layout dosyasında
vereceğimiz yapıya göre sunulan seçenekleri alt kategorilerle ekrana getirir. Aynı zamanda
kullanıcının saklayacağı değerleri, her değere özel bir anahtar atayarak (key – value) bellekte
otomatik olarak saklar.
İlerleyen bölümlerde yer alan örneklerde, bu Activity’leri kullanarak uygulamaların ekranları
oluşturucağız.
5.1.Bir Activity'i Yeniden Oluşturma
Uygulamada çeşitli yollarla (kullanıcının geri tuşuna basması, Activity'nin finish() metodunu
çagırması gibi) Activity'nin sonlanması ya da İngilizce tabiriyle "destroy" olması, gayet doğal bir
işlemdir. Sistemin daha fazla belleğe ihtiyacı olduğunda ya da Activity çok uzun süredir çalıştığı için
durdurulabilir. Bu eğitim belgesinde sonlanan bir Activity'nin yeniden nasıl başlatılacağını
anlatacağız.
Activity, kullanıcının geri tuşuna basması ya da kendini sonlandırması (finish()) durumlarında
tamamıyla kaybolur çünkü sistem Activity'nin artık gerekli olmadığını farzeder. Activity sistem
tarafından sonlandırıldıysa Activity'de bulunan verileri saklayıp, kullanıcı geri dönmek istediğinde
yeniden Activity oluşturarak bu verileri ona yükler. Activity'nin hangi adımda olduğunu sakladığı için
yine o duruma gelerek kullanıcının kaldığı son ekranı gösterir. Sistem tarafından korunan
veriler Bundle objesinde anahtar-değer çiftleriyle tutulur.
45
Normalde sistem Bundle kullanarak uygulamanın Activity layout'unda bulunan tüm view nesnelerini
saklar (editext'e girilen değer gibi). Eğer Activity'niz sonlanır ve yeniden başlatılırsa layout
dosyasındaki nesnelerin son değerleri korunur. Sizin kodunuzu gerektirmeyen bu özellikle birlikte
kullanıcı deneyiminin artırılması ve uygulamanın daha verimli çalışması için daha fazla veri ve
durumun kazanılması gerekebilir, bunun için Activity'nin ilerleyişini çeşitli değişkenlerle saklamanız
gerekmektedir.
Android sisteminin son durum değerlerini kurtarabilmesi için tüm View'lar android:id niteliğinden
sağlanan benzersiz (unique) ID'ye sahip olmak zorundadır.
Activity durumları için daha fazla veri kaydetmek isterseniz,onSaveInstanceState() callback
methodunu ezmeniz (override) gerekmektedir. Sistem, kullanıcı Activity'den çıktığında metodun
sakladığı verileri Bundle nesnesine yükleyerek, sistem Activity'yi yeniden oluşturmak durumunda
kalırsa onRestoreInstanceState() veya onCreate() metodunu çağırdığında aynı Bundle nesnesini
kullanır.
5.2.Activity State'inin Kaydedilmesi
Uygulamanızın Activity'si durmaya başladığında, sistem tarafından onSaveInstanceState() metodu
çağrılır, bu yolla uygulamanızın Activity state'ini anahtar-değer çiftleriyle kaydebilirsiniz. Metodun
olağan gerçeklemesinde (default implementation) Activity'nin durumunu View hiyerarşisine göre
kaydedilir. Örneğin EditText içerisindeki bir değer ya da ListView öğesi içinde ekranın kaydırılma
miktarının kaydedilmesi gibi.
Eğer Activity'nin daha fazla durum bilgilerini kaydetmek
istiyorsanız, onSaveInstanceState() metoduna yeni kod eklemeleri yaparak Bundle nesnesine
anahtar-değer çifti belirtmek durumundasınız. Kod örneğimizle konu daha iyi anlaşılacaktır:
46
1. static final String STATE_SCORE = "playerScore";
2. static final String STATE_LEVEL = "playerLevel";
3. ...
4.
5. @Override
6. public void onSaveInstanceState(Bundle savedInstanceState) {
7. // kullanıcının o anki durumunu kaydediyoruz
8. savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
9. savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);
10.
11. // Her zaman superclass'ı çağırarak methodun temel işlevini de yerine getirmesini
sağlıyoruz
12. super.onSaveInstanceState(savedInstanceState);
13. }
5.3.Activity State'ini Yeniden Yüklemek
Activity'niz yeniden yaratıldığında, yok edilmeden önceki Bundle nesnesine kaydedilmiş durum
bilgilerini yükleyebilirsiniz. onCreate() ve onRestoreInstanceState() metodları
çağrıldığında Bundle nesnesinin üzerinden geçerek durum bilgisini yeniden yüklerler.
Sistem tarafından Activity'nizin yeni bir instance'ı (sınıf örneği) oluştururulduğunda ya da sistem
önceki Activity'yi yeniden yarattığında onCreate() metodu çalışacaktır. onCreate() metodu
çağrıldığında Bundle nesnesinin null (boş) olup olmadığını kontrol etmelisiniz. Eğer null ise sistem
yeni bir Activity oluşturur. Eğer Bundle null değilse eski Activity'nin değerlerini yükleyecektir.
Örneğimizle bir Activity'nin Bundle nesnesi boş değilse eski değerleri nasıl yüklediğimizi görelim:
1. @Override
2. protected void onCreate(Bundle savedInstanceState) {
3. super.onCreate(savedInstanceState); // her zaman öncelikle superclass'ı çağırıyoruz
4.
5. // önceden yok edilen instance'i yaratıp yaratmadığımızı kontrol edelim
6.
7. if (savedInstanceState != null) {
8.
9. // kaydedilen eski activity değerlerini yüklüyoruz.
10. mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
11. mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
12. } else {
13. // yeni bir activity yaratıyoruz
47
14. }
15. ...
16. }
onCreate metoduyla bilgileri yeniden yüklemek yerine onRestoreInstanceState() metoduyla durum
bilgilerini getirebilirsiniz. Sistem onStart metodu sonrası otomatik olarak bu metodu çağırdığı için
Bundle'ın null olup olmadığını kontrol etmek zorunda kalmazsınız. Örneğimizle bu metodu nasıl
kullanıldığını görebilirsiniz:
1. public void onRestoreInstanceState(Bundle savedInstanceState) {</p>
2.
3. <p>// view hiyerarşinin korunması için her zaman öncelikle superclass'ı çağırıyoruz.</p>
4.
5. <p>super.onRestoreInstanceState(savedInstanceState);</p>
6.
7. <p>// kaydedilen durumların yeniden yüklenmesi</p>
8.
9. <p>mCurrentScore = savedInstanceState.getInt(STATE_SCORE);</p>
10.
11. <p>mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);</p>
12.
13. <p>}<br />
Dikkat: onRestoreInstanceState() metodunda view hiyerarşinin korunması için her zaman öncelikle
superclass'ı çağırıyoruz.
Bu sayfadaki parçalar Android Open Source Project kapsamında oluşturulmuş ve paylaşılmış
içeriğin küçük değişiklikler yapılmış hâlidir ve Creative Commons 2.5 Attribution License'ta
belirlenen koşullara göre kullanılmıştır.
Bu eğitim içeriğinin orijinal hâline buradan ulaşabilirsiniz: Recreating an Activity
6.FRAGMENT İLE DİNAMİK KULLANICI ARAYÜZÜ (UI) OLUŞTURMAK
Android'de çok bölmeli (multi-pane) dinamik arayüzler oluşturmak istediğinizde, Activity
davranışlarını ve arayüz bileşenlerini (liste, düğme vs), Activity'nize girip çıkabilen modüller halinde
tutmalısınız. Bu modülleri Fragment sınıfı ile oluşturabilirsiniz. Fragment'lar, yaşam döngülerini
yönetebileceğiniz, özel layout'ları tanımlanabilen iç içe geçmiş Activity'ler gibi davranır.
Fragment'lar ile ilgili bu bölümleri daha kolay öğrenebilmek için Activity yaşam döngüsü belgesini
okumak yararlı olabilir.
48
Bir Fragment kendi layout'unu tanımladığında öteki Fragment'lar ile birlikte farklı kombinasyonlar
oluşturacak şekilde bir Activity'nin içinde yapılandırılabilir. Böylece layout yapılandırmanızı farklı
boyuttaki ekranlar için değiştirebilirsiniz. Örneğin küçük ekranlarda tek fragment'ın gösterilmesini
veya geniş ekranlarda iki veya daha fazla fragment'ın gösterilmesini sağlayabilirsiniz.
Bu eğitim içeriğinde Fragment'lar ile nasıl dinamik bir kullanıcı deneyimi oluşturacağınızı ve farklı
ekran boyutları olan cihazlarda uygulamanızın kullanıcı deneyimini nasıl iyileştireceğinizi
bulacaksınız. Bu sırada Android 1.6'ya kadar eski sürümlerle çalışan cihazları da desteklemeye
devam edebileceksiniz.
Sıradaki Konular
Fragment Oluşturmak: Bir Fragment'ı nasıl oluşturacağınızı ve onun callback metotları içinde temel
davranışlarını nasıl gerçekleyeceğinizi (implementation) öğrenebilirsiniz.
Esnek Arayüz Oluşturmak: Farklı ekranlar için farklı fragment yapılandırmaları sağlayan layout'lar
ile uygulamanızı nasıl oluşturacağınızı öğrenebilirsiniz.
Diğer Fragment'lar ile İletişime Geçmek: Bir Fragment'tan Activity'ye ve diğer Fragment'lara nasıl
iletişim yolu oluşturacağınızı öğrenebilirsiniz.
Bu sayfadaki parçalar Android Open Source Project kapsamında oluşturulmuş ve paylaşılmış
içeriğin küçük değişiklikler yapılmış hâlidir ve Creative Commons 2.5 Attribution License'ta
belirlenen koşullara göre kullanılmıştır.
Bu eğitim içeriğinin orijinal hâline buradan ulaşabilirsiniz: Building a Dynamic UI with Fragments
6.1.Fragment Oluşturmak
Fragment'ı şöyle düşünebilirsiniz: Activity'nin modüler bir bölümüdür. Kendi yaşam döngüsü vardır,
kendi giriş olaylarını (input events) kendisi alır ve Activity çalışmaya devam ederken eklenip
çıkarılabilir. Tıpkı farklı Activity'lerde tekrar tekrar kullanabileceğiniz bir “alt-Activity” gibi de
düşünebilirsiniz.
Bu eğitim içeriğinde Fragment sınıfının nasıl genişletileceğini öğrenebilirsiniz. Bunu yaparken
Android Destekleme Kütüphanesi kullanacağız ve böylece uygulamanız Android 1.6'ya kadar alt
sürüm sistemlerle bile uyumlu kalacaktır.
NOT: Eğer en düşük API seviyesini uygulamanız için 11 ve yukarısı yapmayı düşünüyorsanız,
Android Destekleme Kütüphanesi'ni kullanmanıza gerek kalmayacaktır. Bunun yerine o platform
sürümünün kendi Fragment sınıfını ve ilişkili API'lerini kullanabilirsiniz. Sadece bu eğitim içeriğinin
49
Destekleme Kütüphanesi'nden gelen API'leri kullanmayı esas aldığını ve bundan dolayı platformun
içindeki sınıflardan farklı bazı sınıf ya da API isimleriyle karşılaşabileceğinizi unutmayın.Bu içerikte
anlatılanları yapmaya başlamadan önce projenizi Destekleme Kütüphanesi'ni kullanacak şekilde
yapılandırmanıza gerekiyor. Eğer daha önce Android Destekleme Kütüphanesi kullanmadıysanız
v4 kütüphanesini Destekleme Kütüphanesi'nin Kurulumu belgesine bakarak projenize eklemelisiniz.
Aynı yolu kullanarak Activity'lerinizde Action Bar'ı (eylem çubuğu) kullanmak için v7 appcompat
kütüphanesini de ekleyebilirsiniz. Böylelikle hem Android 2.1 ve üstüyle uyumlu bir uygulamanız olur
hem de FragmentAPI'lerini o sürümlerde bile kullanabilirsiniz.
6.2.Fragment Sınıfı Oluşturmak
Bir Fragment sınıfı oluşturmak için Fragment sınıfını türetin (extend) ve temel yaşam döngüsü
metotlarını -tıpkı Activity sınıfı için yaptığınız gibi- uygulama gereksinimlerinize göre yeniden yazın
(override).
Bir Fragment oluştururmanın önemli bir farkı, layout tanımını yapmak için onCreateView() isimli
callback metodunu kullanmanız gerekmesidir. Aslında bu metot, bir Fragment'ı ayakta tutmak için
gereken tek callback metodudur. Aşağıdaki kod bloğunda, kendi layout'unu tanımlayan basit bir
Fragment örneği görüyorsunuz:
1. import android.os.Bundle;
2. import android.support.v4.app.Fragment;
3. import android.view.LayoutInflater;
4. import android.view.ViewGroup;
5.
6. public class ArticleFragment extends Fragment {
7. @Override
8. public View onCreateView(LayoutInflater inflater, ViewGroup container,
9. Bundle savedInstanceState) {
10. // bu fragment'in layout'unu hazır hale getirelim
11. return inflater.inflate(R.layout.article_view, container, false);
12. }
13. }
Tıpkı bir Activity'de olduğu gibi bir Fragment da diğer yaşam döngüsü callback'lerini (Activity'ye
eklenirken ya da Activity'den çıkarılırken ve Activity'nin yaşam döngüsü durumları arasında geçişler
olurken gerçekleşen) gerçeklemelidir. Örneğin Activity'nin onPause() metodu çağrıldığında o
Activity'deki her Fragment onPause() için bir çağrı alır.
50
6.3.XML Kullanarak Bir Fragment'i Bir Activity'ye Eklemek
Fragment'ların tekrar kullanılabilir yapılar olduğuna ve modüler bir UI bileşeni olduğuna daha önce
değişmiştik. Bununla beraber Fragment sınıfının her örneğinin (instance) ebeveyn
bir FragmentActivity ile ilişkilendirilmesi gerektiğini de belirtmemiz gerek. Bu ilişkiyi sağlamak için
her Fragment'ı Activity layout'unu barındıran XML dosyası içinde tanımlayabilirsiniz.
NOT: Fragment'lar tek başına kullanılamazlar. Mutlaka onu yönetebilecek, onun durumundan
anlayabilecek bir Activity'ye ihtiyaç var ki bu tür Activity'ler de API 11'den sonra SDK'ya entegre
edildi ve ek olarak Android Destekleme Kütüphanesi'nin de içine konuldu.
NOT: FragmentActivity sınıfı Android Destekleme Kütüphanesi içinde sunulan özel bir Activity'dir.
API 11 ve altındaki Android sürümlerde Fragment'ın yönetilebilirliğini sağlar. Eğer projenizin en
düşük API (minSdkVersion) değeri 11 ve yukarısıysa, bu iş için normal Activity sınıfını
kullanabilirsiniz.
Aşağıdaki kod bloğunda geniş ekranlar için düşünülmüş bir Activity layout'u var. Bu layout içinde de
iki tane fragment bulunuyor. Geniş ekranlarda kullanılsın diye “large” eleyicisinin dizin adında
olduğuna dikkatinizi çekeriz.
1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2. android:orientation="horizontal"
3. android:layout_width="fill_parent"
4. android:layout_height="fill_parent">
5.
6. <fragment android:name="com.example.android.fragments.HeadlinesFragment"
7. android:id="@+id/headlines_fragment"
8. android:layout_weight="1"
9. android:layout_width="0dp"
10. android:layout_height="match_parent" />
11.
12. <fragment android:name="com.example.android.fragments.ArticleFragment"
13. android:id="@+id/article_fragment"
14. android:layout_weight="2"
15. android:layout_width="0dp"
16. android:layout_height="match_parent" />
17.
18. </LinearLayout>
51
TÜYO: Farklı ekran boyutları için layout oluşturma konusunda daha fazla bilgi almak
isterseniz Farklı Ekran Boyutlarını Desteklemek belgesine bakabilirsiniz.
Şimdi yukarıda tanımladığımız layout'u Activity'mize uygulayalım:
1. import android.os.Bundle;
2. import android.support.v4.app.FragmentActivity;
3.
4. public class MainActivity extends FragmentActivity {
5. @Override
6. public void onCreate(Bundle savedInstanceState) {
7. super.onCreate(savedInstanceState);
8. setContentView(R.layout.news_articles);
9. }
10. }
Eğer v7 appcompat kütüphanesini kullanıyorsanız, Activiy'niz FragmentActivity'nin bir alt sınıfı
olanActionBarActivity'den türemelidir. (Daha fazla bilgi için Action Bar Eklemek içeriğine
bakabilirsiniz)
NOT: Bir Fragment'ı Activity layout'una XML dosyası üzerinden eklediğinizde bu Fragment'ı çalışma
zamanında kaldıramazsınız. Eğer Fragment'ları kullanıcı etkileşimi sırasında çıkarıp eklemeyi
planlıyorsanız, bundan sonraki içerikte gösterildiği gibi Activity içinde ve Activity başladığında
eklemelisiniz.
Bu sayfadaki parçalar Android Open Source Project kapsamında oluşturulmuş ve paylaşılmış
içeriğin küçük değişiklikler yapılmış hâlidir ve Creative Commons 2.5 Attribution License'ta
belirlenen koşullara göre kullanılmıştır.
Bu eğitim içeriğinin orijinal hâline buradan ulaşabilirsiniz: Creating a Fragment
6.4.Esnek Bir Kullanıcı Arayüzü (UI) Oluşturmak
Farklı farklı ekran boyutlarını destekleyen bir uygulama tasarlarken, birçok esnekliği beraberinde
getiren Fragment'ları kullanabilirsiniz. Farklı layout yapılandırmaları sayesinde
kullanılabilecek ekran alanını en verimli şekilde kullanabilir ve kullanıcı deneyimini artırabilirsiniz.
Örneğin avuca sığan bir telefonda tek bölmeli bir tasarımla sadece bir Fragment göstermek
isteyebilirsiniz. Aynı şekilde daha geniş ekranlı bir tablette kullanıcıya daha fazla bilgi göstermek için
Fragment'ları yan yana kullanabilirsiniz.
52
Resim 1: Farklı boyuttaki ekranlardaki iki Fragment, aynı Activity'nin içinde farklı ayarlamalarla gösteriliyor. Geniş ekranda Fragment'lar yan yana
gelebiliyorken bir avuç büyüklüğündeki telefon gibi cihazlarda tek seferde tek Fragment gösteriliyor. Böyle ufak ekranlarda olası bir kullanıcı
etkileşiminde gösterilen Fragment'ı diğer Fragment ile yer değiştirmek kullanıcı deneyimi açısından iyi olacaktır.
Gelelim Fragment kullanırken olmazsa olmaz FragmentManager sınıfına. FragmentManager sınıfı,
dinamik bir kullanıcı deneyimini sağlayabilesiniz diye çalışma zamanı (runtime) sırasında bir
Activity'ye Fragment ekleme, çıkarma, yer değiştirme gibi işlemleri yapmanıza olanak sağlar. Şimdi
ayrıntılarına bakalım.
6.5.Çalışma Zamanında Bir Fragment'ı Activity'ye Eklemek
Fragment'ları doğrudan <fragment> elementi şeklinde XML layout dosyaları içerisinden Activity'ye
eklemenin dışında, çalışma zamanı sırasında da Activity'ye ekleyebilirsiniz. Böyle bir işleme,
Fragment'ları istediğiniz zaman ekleyip çıkaracağınız zaman ihtiyaç duyarsınız.
Fragment eklemek ya da çıkarmak gibi bir işlemi (transaction) gerçekleştirmek için mutlaka
FragmentManager'ı kullanarak
bir FragmentTransaction oluşturmalısınız. FragmentTransaction size fragment ekleme, çıkarma, yer
değiştirme ve diğer fragment işlemlerini gerçekleştirmenizi sağlayan API'ler sunar. Adı üstünde,
Fragment işlemi yapmanızı sağlar.
Activity'nizin Fragment'ları çıkarabilmesini ya da yer değiştirebilmesini sağlamak istiyorsanız,
Activity'ninonCreate() metodu sırasında ilk olarak istediğiniz Fragment(ları) ekleyebilirsiniz.
Fragment'lar ile çalışırken dikkat etmeniz gereken bir kural da (özellikle çalışma zamanında
ekleyerek kullandığınız Fragment'lar için) Fragment'ın yer alacağı layout'un mutlaka bir taşıyıcı
(container) Viewüzerinde olması gerektiğidir. Bir başka deyişle şöyle açıklayabiliriz: Ekleme-çıkarma
yapacağınız Fragment'ları doğrudan Activity'ye bir yere eklemek istiyorsanız bunun için bir yer
açmalısınız ve o yer bir View nesnesi olmalı. Aşağıdaki örneklerde bu yer bir FrameLayout olarak
karşınıza çıkacak.
53
Aşağıdaki layout, bir önceki içerikte sözünü ettiğimiz "tek seferde tek fragment gösteren" layout'a
alternatif bir layout'tur. Bir Fragment'ı diğeriyle yer değiştirmek için Activity'nin layout'unda Fragment
taşıyıcısı gibi davranan boş bir FrameLayout olması gerekir.
Örneği incelemeye başlamadan önce gözünüzden kaçmasını istemediğimiz bir şey var: Bu
örnekteki layout dosyalarının ismi bir önceki derstekiyle aynı ancak layout dizini "large" son ekini
içermiyor. Bu layout, tek seferde iki fragment sığmayan, geniş ekrandan daha ufak ekranı olan
cihazlar için tasarlanmıştır.
res/layout/news_articles.xml:
1. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"<br />
2. android:id="@+id/fragment_container"<br />
3. android:layout_width="match_parent"<br />
4. android:layout_height="match_parent" />
Activity'nizin içindeyken getSupportFragmentManager() metodunu kullanarak
bir FragmentManagernesnesi elde etmelisiniz. Tüm bunlar Anroid Destekleme Kütüphanesi API'leri
ile gerçekleştireceğimiz işlemler. Ardından beginTransaction() metodunu kullanarak
bir FragmentTransaction nesnesi oluşturuyoruz ve add() metoduyla da fragment'ı FrameLayout'un
olduğu yere ekliyoruz.
NOT: Eğer uygulamanız API 11 ve sonrasını hedef alıyorsa getSupportFragmentManager() metodu
yerine getFragmentManager() metodunu kullanmanız yeterli.
Bu arada Activity'de birden fazla Fragment üzerinde işlem gerçekleştirmek için
aynı FragmentTransactionnesnesini kullanabilirsiniz. Buradaki işleriniz bittiğinde tüm değişiklikleri
kullanıcıya göstermek içincommit() metodunu çağırmanız gerekir.
Şimdi yukarıda anlattıklarımızı kod bloğunda görelim. Yukarıdaki FrameLayout içine (adı
fragment_container idi) bir fragment ekleyelim:
1. import android.os.Bundle;
2. import android.support.v4.app.FragmentActivity;
3.
4. public class MainActivity extends FragmentActivity {
5.
6. @Override
7. public void onCreate(Bundle savedInstanceState) {
8. super.onCreate(savedInstanceState);
9. setContentView(R.layout.news_articles);
10.
11. // Activity'nin fragment_container isimli FrameLayout'u olan
54
12. // bir layout'u kullandığını doğrulayalım; o an başka bir
13. // kaynak (resource) dizinindeki içinde fragment_container
14. // olmayan başka bir layout kullanıyor olabilir
15. if (findViewById(R.id.fragment_container) != null) {
16.
17. // Eğer Activity'yi önceki durumundan (state) geri
18. // dönüştürüyorsak bir şey yapmamıza gerek yok ve
19. // doğrudan return yapabiliriz. Veyahut üst üste gelen
20. //Fragment'ların icabına bakabiliriz
21. if (savedInstanceState != null) {
22. return;
23. }
24.
25. // Activity layout'unun içinde yer alacak yeni bir Fragment oluşturalım
26. HeadlinesFragment firstFragment = new HeadlinesFragment();
27.
28. // Activity'miz Intent'ten gelen özel verilerle başlatılmış
29. // olabilir. Bu nedenle (örnek olması açısından) Intent'in
30. // ekstra verilerini Fragment'a argüman olarak geçiriyoruz
31. firstFragment.setArguments(getIntent().getExtras());
32.
33. //Fragment'ı ‘fragment_container' isimli FrameLayout'a ekliyoruz
34. getSupportFragmentManager().beginTransaction()
35. .add(R.id.fragment_container, firstFragment).commit();
36. }
37. }
38. }
Fragment, çalışma zamanı sırasında FrameLayout taşıyıcısına eklenebildiğinden dolayı, Activity, o
Fragment'ı aynı zamanda kaldırabilir veya başka biriyle yer değiştirebilir. Şimdi bunu nasıl
yapabileceğimize bakalım.
6.6.Bir Fragment'ı Diğeriyle Yer Değiştirmek
Bir Fragment yer değiştirme işlemi aynı Fragment eklemeye benziyor. Sadece add() metoduyla
değil,replace() metoduyla yapılıyor.
Şu detaya dikkatimizi yoğunlaştıralım: Fragment'lar üzerinde gerçekleştirilen ekleme-çıkarma gibi
işlemleri, kullanıcının geriye dönme veya yaptığı işlemi geri alma gibi işlemlerde sıkça
kullanabilirsiniz. Kullanıcının Fragment işlemleri arasında geriye dönebilmesini sağlamak
55
için FragmentTransaction'ı commit() metoduyla çalıştırmadan önce
mutlaka addToBackStack() metodunu çağırmalısınız.
NOT: Bir Fragment'ı yer değiştirdiğinizde veya kaldırdığınızda ve bu işlemi "back stack" denilen yere
eklediğinizde fragment kaldırılır ve durur (yok edilmez). Kullanıcı Fragment'ı geri dönüştürerek
geriye dönerse o Fragment yeniden başlatılır. Eğer işlemi "back stack"e eklemezseniz, Fragment
kaldırıldığında veya yer değiştirildiğinde yok edilir.
Aşağıda bir Fragment'ı diğeriyle yer değiştirme işlemini örnekle görebilirsiniz:
1. // Fragment'ı oluşturalım ve göstereceği makaleyi
2. // (article) ona argüman olarak verelim
3. ArticleFragment newFragment = new ArticleFragment();
4.
5. Bundle args = new Bundle();
6. args.putInt(ArticleFragment.ARG_POSITION, position);
7. newFragment.setArguments(args);
8.
9. FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
10.
11. // fragment_container layout'u içinde o anki
12. // Fragment ile istediğiniz bir fragment'ı yer
13. // değiştirin ve bu işlemi back stack'e de ekleyin
14. // ki kullanıcı geri döndüğünde önceki Fragment'ı görebilsin
15. transaction.replace(R.id.fragment_container, newFragment);
16. transaction.addToBackStack(null);
17.
18. // yapacak bir şey kalmadı. işlemi FragmentManager'a teslim ediyoruz
19. transaction.commit();
addToBackStack() metodu yapılan işlemi ifade eden eşsiz bir string parametresini isim olarak alır.
EğerFragmentManager.BackStackEntry API'leriyle ileri seviye Fragment işleri yapmayacaksanız
işleme bir isim vermenize gerek olmayacaktır. Yukarıdaki kodda bu yüzden null parametresi
geçilmiştir.
Bu sayfadaki parçalar Android Open Source Project kapsamında oluşturulmuş ve paylaşılmış
içeriğin küçük değişiklikler yapılmış hâlidir ve Creative Commons 2.5 Attribution License'ta
belirlenen koşullara göre kullanılmıştır.
Bu eğitim içeriğinin orijinal hâline buradan ulaşabilirsiniz: Building a Flexible UI
56
6.7.Diğer Fragment'lar ile İletişime Geçmek
Fragment arayüz bileşenlerini tekrar tekrar kullanabilmek istiyorsanız her birini, kendi kendini
taşıyabilen, kendi layout'unu ve davranışını tanımlayabilen modüler bir yapıda inşa etmelisiniz.
Tekrar kullanılabilir Fragment'ları bir kere tanımladıktan sonra, onları bir Activity ile ilişkilendirmeli
ve genel arayüz mantığında yerine koymak için uygulama mantığına oturtmalısınız.
Genellikle bir Fragment'ı diğeriyle iletişime sokmak isteyeceksiniz. Örneğin bir kullanıcı olayına göre
diğerinin içeriğini değiştirmek isteyeceksiniz. Fragment'tan Fragment'a yapılacak tüm iletişim, ilişkili
oldukları Activity üzerinden gerçekleşir. Activity, burada trafik polisi gibidir. İki Fragment onsuz asla
doğrudan iletişime geçmez.
Bu eğitim içeriğinde şunları göreceğiz:
Fragment'tan mesaj göndermek
o Arayüz sınıfının tanımlanması
o Arayüz sınıfının gerçeklemesi
Fragment'a mesaj göndermek
6.8.Fragment'tan Mesaj Göndermek
Arayüz sınıfının tanımlaması
Bir Fragment'ın bağlı olduğu Activity ile iletişime geçmesi için Fragment sınıfınızın içinde bir arayüz
sınıfı tanımlayabilir ve onu da Activity içinde gerçekleyebilirsiniz. Fragment, onAttach8) yaşam
döngüsü olayı boyunca bu arayüz (interface) sınıfının gerçeklemesini (implementation) yakalar ve
bu arayüz sınıfının metotlarını Activity ile haberleşmek için çağırır.
Aşağıda Fragment'tan Activity'ye doğru bir iletişim örneği var:
1. public class HeadlinesFragment extends ListFragment {
2. OnHeadlineSelectedListener mCallback;
3.
4. // Taşıyıcı durumdaki Activity bu interface'i mutlaka implemente etmeli
5. public interface OnHeadlineSelectedListener {
6. public void onArticleSelected(int position);
7. }
8.
9. @Override
10. public void onAttach(Activity activity) {
11. super.onAttach(activity);
12.
13. // bununla taşıyıcı activity'nin bu callback interface'ini
57
14. // gerçeklediğinden emin oluruz. Etmemişse hata fırlatırız
15. try {
16. mCallback = (OnHeadlineSelectedListener) activity;
17. } catch (ClassCastException e) {
18. throw new ClassCastException(activity.toString()
19. + " mutlaka OnHeadlineSelectedListener");
20. }
21. }
22.
23. ...
24. }
Bu kodla birlikte artık Fragment, mCallback'in onArticleSelected() metodu yardımıyla Activity'ye
mesaj teslim edebilir. mCallBack, OnHeadlineSelectedListener interface'inin bir örneği (instance)
oluyor.
Örneğin aşağıdaki metod, kullanıcı bir liste öğesine tıklayınca çağırılıyor. Burada Fragment, callback
interface'ini (mCallback) kullanarak olayı üstteki Activity'ye iletiyor.
1. @Override
2. public void onListItemClick(ListView l, View v, int position, long id) {
3. // olayı üstteki activity'ye iletelim
4. mCallback.onArticleSelected(position);
5. }
6.9.Arayüz Sınıfının Gerçeklemesi
Fragment'tan olaylarla ilişkili callback'leri alabilmek için ev sahibi Activity'nin Fragment sınıfı içinde
tanımlanmış arayüz (interface) sınıfını gerçeklemesi gerekiyor.
Aşağıdaki örnekte gördüğünüz Activity, yukarıdaki örnekte yer alan interface'i gerçekliyor.
1. public static class MainActivity extends Activity
2. implements HeadlinesFragment.OnHeadlineSelectedListener{
3. ...
4.
5. public void onArticleSelected(int position) {
6. // kullanıcı HeadLinesFragment'tan bir yazının başlığını seçer
7. // burada da yazıyı gösterecek işlemleri başlatırız
8. }
9. }
58
6.10.Fragment'a Mesaj Göndermek
Ev sahibi Activity, bir örneğine (instance) findFragmentById() metoduyla eriştiği Fragment'a isterse
mesaj da gönderebilir. Ardından o Fragment'ın public metotlarını doğrudan çalıştırabilir.
Örneğin, yukarıdaki örneklerde de geçtiği gibi bir Activity hayal edin. İçinde yazı başlıklarının
listelendiği Fragment'tan (HeadLinesFragment) başka bir Fragment daha olsun ve seçilen başlığa
göre bu Fragment'ta ilgili içerik gösterilsin. Bu Activity yukarıdaki callback metodunun döndürdüğü
veriden yararlanarak ilgili içeriği diğer Fragment'ta gösterebilir. Aşağıdaki örnekte de bunu
gerçekleştiriyoruz.
Activity, callback metoduyla gelen bilgiden yararlanarak bu bilgileri diğer Fragment'ta göstertiyor:
1. public static class MainActivity extends Activity
2. implements HeadlinesFragment.OnHeadlineSelectedListener{
3. ...
4.
5. public void onArticleSelected(int position) {
6. // kullanıcı HeadlinesFragment'tan bir yazının başlığını seçti
7. // şimdi seçtiği başlığa göre bir gösterme işlemi yapalım
8.
9. // önce detaylı bilgiyi göstereceğimiz ArticleFragment'a erişelim
10. ArticleFragment articleFrag = (ArticleFragment)
11. getSupportFragmentManager().findFragmentById(R.id.article_fragment);
12.
13. if (articleFrag != null) {
14. // eğer articleFrag kullanılabilirse iki layout'u da
15. // ekranda görebiliyoruz demektir
16.
17. // ArticleFragment'ın içideyken içeriğini güncelleyecek
18. // metodu çağıralım
19. articleFrag.updateArticleView(position);
20. } else {
21. // eğer articleFrag kullanılabilir değilse
22. // tek parçalı bir layout'tayız demektir ve fragment'ları yer
23. // değiştirmemiz gerekir
24.
25. // bir Fragment oluşturalım ve seçilen başlığa göre ona belli
26. // argümanlar verelim
27. ArticleFragment newFragment = new ArticleFragment();
59
28. Bundle args = new Bundle();
29. args.putInt(ArticleFragment.ARG_POSITION, position);
30. newFragment.setArguments(args);
31.
32. FragmentTransaction transaction =
getSupportFragmentManager().beginTransaction();
33.
34. // fragment_container view'ını bu yeni fragment ile değiştirelim
35. // ve back stack'e bir işlem ekleyelim ki kullanıcı
36. // geri döndüğünde daha önce gördüğü Fragment'ı görebilsin
37. transaction.replace(R.id.fragment_container, newFragment);
38. transaction.addToBackStack(null);
39.
40. // işlerimizi bitirelim
41. transaction.commit();
42. }
43. }
44. }
Bu sayfadaki parçalar Android Open Source Project kapsamında oluşturulmuş ve paylaşılmış
içeriğin küçük değişiklikler yapılmış hâlidir ve Creative Commons 2.5 Attribution License'ta
belirlenen koşullara göre kullanılmıştır.
Bu eğitim içeriğinin orijinal hâline buradan ulaşabilirsiniz: Communicating with Other Fragments
7.LAYOUT
Android uygulamalarında ekran tasarımları res klasörü altında bulunan layout dosyaları ile
belirlenir. Bu dosyalar xml formatında hazırlanan dosyalardır ve Android uygulamalarına özel
etiketler kullanarak görsel öğelerin yerleşimlerini ve özelliklerini bildirirler.
1. <?xml version="1.0" encoding="utf-8"?><br />
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"<br />
3. android:layout_width="fill_parent"<br />
4. android:layout_height="fill_parent"<br />
5. android:orientation="vertical" ><br />
6. <br />
7. <ListView<br />
8. android:id="@android:id/list"<br />
60
9.
android:layout_width="fill_parent"<
br />
10.
android:layout_height="wrap_conte
nt" /><br />
11. <br />
12. </LinearLayout>
Bir ekranın görünümü genellikle iki farklı yerleşim tipi kullanılarak belirlenir.
Bunlar RelativeLayout ve LinearLayout olarak ikiye ayrılır.
LinearLayout yerleşimi kullanıldığında öğeler sırayla ekrana dizilirler ve ekrandaki yerleşimleri
ekranın en tepesinden en altına doğru sırayla gerçekleşir. Yukarıdaki örnekte, ListView öğesinin
altına başka bir öğe eklendiğinde ilk olarak liste ve listenin altında bu yeni öğe görüntülenir. Öğelerin
uzunluk ve genişlikleri android:layout_width ve android:layout_height özellikleriyle belirlenir.
Burada fill_parent (ana öğe ne kadar genişse hepsini doldurur) ve wrap_content (öğe içerisinde
yer alan metin veya resim kadar yer kaplar) değerleri kullanılabileceği gibi, piksel cinsinden uzunluk
da verilebilir. Eğer piksel vererek ebat belirleyeceksek, px birimi yerine dp birimini kullanmamız
faydalı olacaktır. Android cihazlarda farklı ebatlarda ekranlar olduğundan, px cinsinden verilen
piksellerin tasarımı her cihazda farklı oluşturacaktır.dp birimi ise ekran boyutuna göre ölçeklendirme
yapmaktadır ve farklı cihazlarda benzer görünümler elde etmenizi sağlar.
RelativeLayout görsel öğeleri diğer öğelere göre referans alarak dizer. RelativeLayout tasarımında
ilk eklenen öğe ekranın en tepesinde yer alır. Daha sonra eklenen
öğeler android:layout_below (verilen ID’nin altında), android:layout_above (verilen ID’nin
üzerinde), android:layout_toLeftOf (verilen ID’nin solunda) ve android:layout_toRightOf (verilen
ID’nin sağında) şeklinde sıralanır. Bu şekilde ekranda oluşturulan bütün öğeleri bir öğeyi referans
alarak dizmemiz mümkündür. Öğelerin ebatları ise
android:layout_height ve android:layout_width metotlarıyla belirlenir.
1. <?xml version="1.0" encoding="utf-8"?><br />
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"<br
/>
3. android:layout_width="fill_parent"<br />
4. android:layout_height="fill_parent"<br />
5. android:orientation="vertical" ><br />
6. <br />
7. <EditText<br />
8. android:id="@+id/note_title"<br />
61
9.
android:layout_width="fill_parent"<
br />
10.
android:layout_height="wrap_conte
nt"<br />
11.
android:layout_marginTop="10sp"<
br />
12.
android:hint="Metin..." /><
br />
13. <br />
14. <EditText<br />
15. android:id="@+id/note_latitude"<br
/>
16.
android:layout_width="fill_parent"<
br />
17.
android:layout_height="wrap_conte
nt"<br />
18.
android:layout_below="@id/note_tit
le"<br />
19.
android:layout_marginTop="10sp"<
br />
20.
android:hint="Enlem..." />
<br />
21. <br />
22. <EditText<br />
23.
android:id="@+id/note_longitude"<
br />
62
24.
android:layout_width="fill_parent"<
br />
25.
android:layout_height="wrap_conte
nt"<br />
26.
android:layout_below="@id/note_la
titude"<br />
27.
android:layout_marginTop="10sp"<
br />
28.
android:hint="Boylam..." />
;<br />
29. <br />
30. <Button<br />
31.
android:id="@+id/add_note_button
"<br />
32.
android:layout_width="fill_parent"<
br />
33. android:layout_height="40sp"<br />
34.
android:layout_below="@id/note_lo
ngitude"<br />
35. android:text="Ekle" /><br
/>
36. <br />
37. </RelativeLayout>
Android: id özelliği her öğeye bir tanımlayıcı verilmesini sağlar ve öğelere kaynak kod içinden
erişmemize ve müdahale etmemize yardımcı olur. Burada yaratılan id değerleri R dosyasında
otomatik olarak oluşturulur ve bunlara kaynak kod içinden aşağıdaki gibi erişilir.
1. EditText titleView = (EditText) <br />
2. findViewById(R.id.note_title);
63
findViewById metodu R dosyası içinden note_title id’sine sahip EditText öğesine erişmemizi
sağlar. Bu şekilde ekran üzerindeki öğelerin özelliklerini değiştirebilir ya da aksiyonlar ekleyebiliriz.
1.
((Button) findViewById(R.id.close_button)).setOnClickListener(new OnClickList
ener() {<br />
2. <br />
3.
@Over
ride<br />
4.
public&
nbsp;void onClick(View v) {<br />
5.
finish();<br />
6. }<br />
7. });
Yukarıdaki örnekte close_button adlı butona setOnClickListener metodu kullanılarak düğmeye
basıldığında harekete geçen bir eylem eklenmiştir. Kullanıcı düğmeye bastığında finish metodu
harekete geçerek ekranı kapatacaktır.
Layout dosyalarında bir öğeye id atanırken @+id yazımı kullanılır. Bu şekilde öğelere kendi
belirlediğimiz isimleri verebiliriz. @id ise layout dosyasında önceden tanımlanmış bir öğeye referans
vermek için kullanılır. @drawable, drawable klasörüne atılan resim dosyalarına referans verir. Bu
şekilde bir resim yerleştirmek ya da arka plan belirlemek istiyorsak kaynak belirtmek
için @drawable yazımını kullanmamız gerekir. Bir düğmeye ya da metin
öğesine string.xml dosyasında belirttiğimiz bir yazıyı koymak istiyorsak@string yazımıyla bu
dosyada bulunan değerlere erişebiliriz. @android ile işletim sisteminde tanımlanmış değerlere
erişebiliriz.
7.1.Linear Layout Kullanımı
Hatırlatma: Bu eğitim ileri seviye olduğundan, belirli bir örnek üzerinden uygulamalı olarak
anlatılmıştır.
Linear Layout kullanımı Android'de, tüm nesneleri tek bir yönde kullanmamızı sağlar. Linear layout
sayesinde nesneleri android:orientation özelliğini kullanarak, tamamen yatay veya dikey olarak
konumlandırabiliriz.
64
ADT'de yeni bir proje oluşturarak başlayalım. Adını LayoutsDemo yapalım.
İlk olarak activity_main.xml'in içine bir tane düğme ekliyoruz. Daha sonra bu XML'in içine diğer layout
ekranlarını açacak düğmeleri de ekleyeceğiz.
1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="vertical" >
6.
7. <Button
8. android:id="@+id/btn_show_linear_layouts"
9. android:layout_width="match_parent"
10. android:layout_height="wrap_content"
11. android:text="Linear Layout" />
12. </LinearLayout>
65
XML kodunu yazdıktan sonra MainActivity'ye setContentView metodu ile bu layout sınıfını
veriyoruz.MainActivity'nin içinden btn_show_linear_layouts id'li düğmeyi findViewById metodu ile
referansını alıp,OnClickListener set ediyoruz.
Listener'ın onClick metoduna LinearLayoutDemoActivity isimli activity'i açacak kodu yazıyoruz:
1. public class MainActivity extends Activity {
2.
3. @Override
4. protected void onCreate(Bundle savedInstanceState) {
5. super.onCreate(savedInstanceState);
6. setContentView(R.layout.activity_main);
7.
8. Button showLinearLayoutDemo = (Button)
(findViewById(R.id.btn_show_linear_layouts));
9. showLinearLayoutDemo.setOnClickListener(new OnClickListener() {
10. public void onClick(View v) {
11. startActivity(new Intent(MainActivity.this, LinearLayoutDemoActivity.class));
12. }
13. });
14. }
15.
16. }
17. //Eklenen her activity sınıfının AndroidManifest.xml dosyasına ekleneceğini unutmayın.
Yoksa hata alırsınız.İkinci aşama olarak activity_linear_layout_demo.xml isimli layout'u
oluşturuyoruz. Layout'un içine dört tane düğme ekliyoruz:
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="vertical" >
6.
7. <Button
8. android:id="@+id/btn_show_horizantal_example"
9. android:layout_width="match_parent"
10. android:layout_height="wrap_content"
11. android:text="Horizantal Example" />
12.
66
13. <Button
14. android:id="@+id/btn_show_vertical_example"
15. android:layout_width="match_parent"
16. android:layout_height="wrap_content"
17. android:text="Vertical Example" />
18.
19. <Button
20. android:id="@+id/btn_show_weight_example"
21. android:layout_width="match_parent"
22. android:layout_height="wrap_content"
23. android:text="Weight Example" />
24.
25. <Button
26. android:id="@+id/btn_show_gravity_example"
27. android:layout_width="match_parent"
28. android:layout_height="wrap_content"
29. android:text="Gravity Example" />
30.
31. </LinearLayout>
67
Oluşturduğumuz bu dört düğmenin yardımıyla örnek layout'ları açacak
şekilde LinearLayoutDemoActivitysınıfı içine gerekli kodları yazıyoruz:
1. public class LinearLayoutDemoActivity extends Activity {
2.
3. public static final int HORIZANTAL_EXAMPLE = 0;
4. public static final int VERTICAL_EXAMPLE = 1;
5. public static final int WEIGHT_EXAMPLE = 2;
6. public static final int GRAVITY_EXAMPLE = 3;
7.
8. @Override
9. protected void onCreate(Bundle savedInstanceState) {
10. super.onCreate(savedInstanceState);
11. setContentView(R.layout.activity_linear_layout_demo);
12.
13. Button showHorizantalExample = (Button)
findViewById(R.id.btn_show_horizantal_example);
14. showHorizantalExample.setOnClickListener(new OnClickListener() {
15. public void onClick(View v) {
16. showExample(HORIZANTAL_EXAMPLE);
17. }
18. });
19.
20. Button showVerticalExample = (Button)
findViewById(R.id.btn_show_vertical_example);
21. showVerticalExample.setOnClickListener(new OnClickListener() {
22. public void onClick(View v) {
23. showExample(VERTICAL_EXAMPLE);
24. }
25. });
26.
27. Button showWeightExample = (Button) findViewById(R.id.btn_show_weight_example);
28. showWeightExample.setOnClickListener(new OnClickListener() {
29. public void onClick(View v) {
30. showExample(WEIGHT_EXAMPLE);
31. }
32. });
33.
68
34. Button showGravityExample = (Button) findViewById(R.id.btn_show_gravity_example);
35. showGravityExample.setOnClickListener(new OnClickListener() {
36. public void onClick(View v) {
37. showExample(GRAVITY_EXAMPLE);
38. }
39. });
40. }
41.
42. private void showExample(int exampleId) {
43. Intent intent = new Intent(LinearLayoutDemoActivity.this,
LinearLayoutExampleActivity.class);
44. intent.putExtra("exampleId", exampleId);
45. startActivity(intent);
46. }
47. }
Yukarıda bulunan bütün düğmeler aynı activity'i açmaktadır. Activity'nin içine geçilen parametre
tipine göre setContentView metoduna verilen layout id'si değişmektedir.
Açılan LinearLayoutExamplActivity'nin örnek kodu aşağıdaki gibidir:
1. public class LinearLayoutExampleActivity extends Activity {
2.
3. @Override
4. protected void onCreate(Bundle savedInstanceState) {
5. super.onCreate(savedInstanceState);
6. int exampleId = getIntent().getIntExtra("exampleId", 0);
7.
8. switch (exampleId) {
9. case LinearLayoutDemoActivity.HORIZANTAL_EXAMPLE:
10. setContentView(R.layout.activity_linear_layout_horizantal);
11. break;
12. case LinearLayoutDemoActivity.VERTICAL_EXAMPLE:
13. setContentView(R.layout.activity_linear_layout_vertical);
14. break;
15. case LinearLayoutDemoActivity.WEIGHT_EXAMPLE:
16. setContentView(R.layout.activity_linear_layout_weight);
17. break;
18. case LinearLayoutDemoActivity.GRAVITY_EXAMPLE:
19. setContentView(R.layout.activity_linear_layout_gravity);
69
20. break;
21.
22. default:
23. break;
24. }
25. }
26. }
Buraya kadar anlatılan kısım genel özellikleri yansıtmaktadır. Bundan sonraki kısımda Linear
Layout da bulunan yeteneklere bakalım.
Yatay Örnek
Linear Layout'un içine eklediğiniz view'ları yatay bir şekilde göstermek için aslında herhangi bir şey
belirtmemize gerek yok. Öntanımlı olarak android:orientation="horizontal" olarak gelmektedir.
Burada dikkat edilmesi gereken nokta, eğer yatayda çok fazla view eklemek istiyorsak Linear
Layout'u bir Scroll View içine koymamızın gerekmesidir. Aksi takdirde son olarak eklediğimiz
view'lara yer kalmadığı zaman bunu sistem ekrana doğru düzgün bir şekilde çizemeyecektir.
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="horizontal" >
6.
7. <Button
8. android:id="@+id/btn_blue"
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:background="@color/blue_color"
12. android:text="Blue"
13. android:textColor="@color/white_color" />
14.
15. <Button
16. android:id="@+id/btn_purple"
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:background="@color/purple_color"
70
20. android:text="Purple"
21. android:textColor="@color/white_color" />
22.
23. <Button
24. android:id="@+id/btn_green"
25. android:layout_width="wrap_content"
26. android:layout_height="wrap_content"
27. android:background="@color/green_color"
28. android:text="Green"
29. android:textColor="@color/white_color" />
30.
31. <Button
32. android:id="@+id/btn_orange"
33. android:layout_width="wrap_content"
34. android:layout_height="wrap_content"
35. android:background="@color/orange_color"
36. android:text="Orange"
37. android:textColor="@color/white_color" />
38.
39. </LinearLayout>
71
Dikey Örnek
Layout içine koyduğumuz view'ları dikey bir sırada göstermek istiyorsak, Linear
Layout'un orientationözelliğini vertical olarak belirtmemiz gerekmektedir.
android:orientation="vertical"
Aynı Yükseklik Ya Da Genişliğe Sahip Örnekler
Birçok projede aynı genişliğe veya aynı yüksekliğe sahip view'ları görebilirsiniz. Bunları yapmak için
LinearLayout'un weightSum ve viewların layout_weight özelliğini kullanmalısınız. Linear Layout
içine iki tane view koymuşsak ve bunların aynı genişliğe sahip olmasını istiyorsak; o zaman Linear
Layout'un orientation özelliğini horizontal yapıp weightSum özelliğini 1 yapmalıyız (Eğer Linear
Layout'un weightSum özelliğini herhangi bir değer vermezsek, içine koyulan layout_weight'lerin
toplam değeri otomatik olarak hesaplanıp set edilecektir). Layout'un içine koyulan view'larında
layout_weight değerlerini eşit yapmalıyız.
Bu örnek için her iki view'ın da ilgili değeri 0.5 olacaktır. Aslında layout_weight değeri o view'ın
ekranda yüzdesel olarak ne kadar yer kaplayacağını verebilmemizi sağlar. Bu oran ekran
genişliğinden bağımsız bütün genişliklerde düzgün bir şekilde çalışmaktadır: (Daha fazla bilgi ve
örnek için bu adresteki örnekte incelenebilir).
72
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="match_parent"
4. android:layout_height="wrap_content"
5. android:orientation="horizontal"
6. android:weightSum="1" >
7.
8. <Button
9. android:id="@+id/btn_blue"
10. android:layout_width="wrap_content"
11. android:layout_height="match_parent"
12. android:background="@color/blue_color"
13. android:layout_weight="0.5"
14. android:text="Blue Button"
15. android:textColor="@color/white_color" />
16.
17. <Button
18. android:id="@+id/btn_green"
19. android:layout_width="wrap_content"
20. android:layout_height="match_parent"
21. android:background="@color/green_color"
22. android:layout_weight="0.5"
23. android:text="Green Button"
24. android:textColor="@color/white_color" />
25.
26. </LinearLayout>
73
Eğer dikey düzlemde eşit görüntü vermek istiyorsak bu sefer orientation değerini vertical yapmamız
gerekmektedir.
Performans Hatırlatması: Örneğin yatay düzlemde weight değerlerini veriyorsak,
viewların layout_widthdeğerlerini 0dp yapmamız performans açısından daha verimli sonuçlar verir.
Gravity Örneği
Linear Layout'un içine koyduğumuz view'ları nerede konumlanacağını gravity değeri ile verebiliriz.
Aşağıda örnekte tam ortaya gelecek şekilde değer verilmiştir:
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="vertical"
6. android:gravity="center" >
7. <!--
8. android:gravity="left"
9. android:gravity="right"
10. android:gravity="center_vertical"
11. android:gravity="center_horizontal"
12. android:gravity="center"
74
13. -->
14.
15. <Button
16. android:id="@+id/btn_blue"
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:background="@color/blue_color"
20. android:text="Blue Button"
21. android:textColor="@color/white_color" />
22.
23. <Button
24. android:id="@+id/btn_purple"
25. android:layout_width="wrap_content"
26. android:layout_height="wrap_content"
27. android:background="@color/purple_color"
28. android:text="Purple"
29. android:textColor="@color/white_color" />
30.
31. <Button
32. android:id="@+id/btn_green"
33. android:layout_width="wrap_content"
34. android:layout_height="wrap_content"
35. android:background="@color/green_color"
36. android:text="Green Button"
37. android:textColor="@color/white_color" />
38.
39. <Button
40. android:id="@+id/btn_orange"
41. android:layout_width="wrap_content"
42. android:layout_height="wrap_content"
43. android:background="@color/orange_color"
44. android:text="Orange"
45. android:textColor="@color/white_color" />
46.
47. </LinearLayout>
Center
75
Right
Alıştırma
İndirebileceğiniz örnek kodlarda, projeye birden fazla özelliğin bir arada kullanıldığı bir örnek daha
ekli. Üzerinde gerekli çalışmaları yaparak aşağıdaki ekran görüntüsünü elde edebilirsiniz.
76
77
Kaynakça https://developer.android.com/index.html
http://source.android.com/
http://www.yazilimcilardunyasi.com/p/mobil-programlama.html
http://www.programlamadefteri.com/android-programlama-dersleri
https://gelecegiyazanlar.turkcell.com.tr/konu/android