Java’da XML dosyası oluşturmam gerektiğinde bulduğum kodu, başkalarının da işine yarar umuduyla buraya da yazayım.
Amaç şu aşağıdaki formatta bir XML dosyası oluşturmak:
<sirket> <calisan id="1"> <ad>İsim</ad> <soyAd>SOYİSİM</soyAd> <maas>1000</maas> </calisan> <calisan id="2"> <ad>İsim2</ad> <soyAd>SOYİSİM2</soyAd> <maas>1000</maas> </calisan> </sirket>
Kodun orijinali üzerinde fazla değişiklik yapmadan aşağıdaki haliyle inceleyelim:
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class CreateXML {
public static void main(String[] args) {
try {
/**
* Kodun kaynağı:
* http://www.mkyong.com/java/how-to-create-xml-file-in-java-dom/
*/
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
/** Şirket */
Document doc = docBuilder.newDocument();
Element rootElement = doc.createElement("sirket");
doc.appendChild(rootElement);
/** Çalışan */
Element staff = doc.createElement("calisan");
rootElement.appendChild(staff);
/** Çalışana id özelliği atama */
Attr attr = doc.createAttribute("id");
attr.setValue("1");
staff.setAttributeNode(attr);
/** Şöyle bir de kısayolu var */
// staff.setAttribute("id", "1");
/** Ad */
Element firstname = doc.createElement("ad");
firstname.appendChild(doc.createTextNode("İsim"));
staff.appendChild(firstname);
/** Soyad */
Element lastname = doc.createElement("soyAd");
lastname.appendChild(doc.createTextNode("SOYİSİM"));
staff.appendChild(lastname);
/** Maaş */
Element salary = doc.createElement("maas");
salary.appendChild(doc.createTextNode("1000"));
staff.appendChild(salary);
/** İçeriğin bir XML dosyasına yazılması */
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(new File("file.xml"));
transformer.transform(source, result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Eğer hatasız çalışırsa proje klasörü içinde “file.xml” adında bir dosya oluşacaktır. İçeriği de aşağıdaki gibi:
<?xml version="1.0" encoding="UTF-8" standalone="no"?> <sirket> <calisan id="1"> <ad>İsim</ad> <soyAd>SOYİSİM</soyAd> <maas>1000</maas> </calisan> </sirket>
Fazla açıklama da yazmadık ama adamlar zaten güzel yazmışlar, açıklama yazmaya pek gerek kalmamış.
Kaynak: mkyong.com
Üzerinde çalıştığım bir Android projesinde EditText alanına girilen e-mail değerinin gerçekten de bir e-mail adresi mi olduğunun kontrol edilmesi gerekiyordu. Bunun için aşağıdaki kodu bulup kullandım.
boolean isEmailValid(String email) {
String expression = "^[\\w\\-]([\\.\\w])+[\\w]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
CharSequence inputStr = email;
Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
return matcher.matches();
}
Girilen tüm değerleri doğru test ediyor mu bilemem ama benim işimi görecek kadar iyi çalışıyor. Aşağıdaki kod bloğu ile test ettiğimde;
ArrayList<String> addresses = new ArrayList<String>();
addresses.add(" ");
addresses.add("test");
addresses.add("test.com");
addresses.add("test@com");
addresses.add("test@test.com");
addresses.add("test@test.com.");
addresses.add("test@test.com.tr");
addresses.add("test.test@test.com.tr");
addresses.add("test@türkçe.karakter.tr");
for (int i = 0; i < addresses.size(); i++) {
System.out.println(addresses.get(i) + " :: "
+ isEmailValid(addresses.get(i)));
}
şu aşağıdaki çıktıyı verdi:
:: false
test :: false
test.com :: false
test@com :: false
test@test.com :: true
test@test.com. :: false
test@test.com.tr :: true
test.test@test.com.tr :: true
test@türkçe.karakter.tr :: false
Yeniden anlamış olduk ki regular expressions hayat kurtarır :)
Kaynak: zparacha.com
Java’da List, ArrayList, Set vb Collections framework yapıları ve bunların metodları (add, remove, sort vb) sağladığı kolaylıklar sebebiyle bolca kullanır. Örneğin bir ArrayList içinde String ya da Integer tipinde nesneler varsa ve bunları sıralamamız gerekiyorsa Collections.sort(liste_ismi); şeklinde bir kullanımla listeyi sıralı hale getirebiliriz. Buna küçük bir örnek verelim. Aşağıdaki kod parçası bir ArrayList oluşturup içine 5 tane String tipinde eleman ekliyor, elemanları sıra ile konsola yazdırıyor, sıralıyor ve son olarak sıralı listeyi konsola yazdırıyor.
import java.util.ArrayList;
import java.util.Collections;
public class ObjectSort {
/**
* @author Oguz
*/
public static void main(String[] args) {
ArrayList mList = new ArrayList();
mList.add("Black Sabbath");
mList.add("Judas Priest");
mList.add("Jimi Hendrix");
mList.add("Dire Straits");
mList.add("Pink Floyd");
// Sıralanmamış listeyi yazdırıyoruz:
System.out.println("Sıralanmamış dizi:");
listeyiGoster(mList);
// listeyi sıralıyoruz
Collections.sort(mList);
// Sıralanmış diziyi gösteriyoruz
System.out.println("Sıralanmış dizi:");
listeyiGoster(mList);
}
private static void listeyiGoster(ArrayList mList) {
for (int i = 0; i < mList.size(); i++) {
System.out.println(i + " -> " + mList.get(i));
}
}
}
Kodun çıktısı aşağıdakine benzer olur:
Sıralanmamış dizi:
0 -> Black Sabbath
1 -> Judas Priest
2 -> Jimi Hendrix
3 -> Dire Straits
4 -> Pink Floyd
Sıralanmış dizi:
0 -> Black Sabbath
1 -> Dire Straits
2 -> Jimi Hendrix
3 -> Judas Priest
4 -> Pink Floyd
Elemanlarının tipi Integer, String, Double vs olan listeleri sıralamak basit, peki kendi nesnelerimizi nasıl sıralarız? Mesela String tipinde ad, soyad ve int tipinde doğum yılı alanları olan ‘Ogrenci’ tipinde elemanları olan bir liste. Deneyelim..
Önce Ogrenci classımızı yazalım:
public class Ogrenci {
private String ad;
private String soyAd;
private int dogumYili;
public Ogrenci(String ad, String soyAd, int dogumYili) {
super();
this.ad = ad;
this.soyAd = soyAd;
this.dogumYili = dogumYili;
}
public String getAd() {
return ad;
}
public void setAd(String ad) {
this.ad = ad;
}
public String getSoyAd() {
return soyAd;
}
public void setSoyAd(String soyAd) {
this.soyAd = soyAd;
}
public int getDogumYili() {
return dogumYili;
}
public void setDogumYili(int dogumYili) {
this.dogumYili = dogumYili;
}
@Override
public String toString() {
return this.getAd() + " " + this.getSoyAd() + " :: "
+ this.getDogumYili();
}
}
Şimdi main classın içinde elemanlarının tipi Ogrenci olan bir liste oluşturup elemanlar ekleyelim ve konsola yazdıralım.
public static void main(String[] args) {
ArrayList mList = new ArrayList();
mList.add(new Ogrenci("F. Oğuz", "ÖZKEROĞLU", 1988));
mList.add(new Ogrenci("Ad", "SOYAD", 1985));
mList.add(new Ogrenci("İsim", "SOYİSİM", 2000));
mList.add(new Ogrenci("Deneme", "YANILMA", 2011));
// Sıralanmamış listeyi yazdırıyoruz:
listeyiGoster(mList);
}
private static void listeyiGoster(ArrayList<Ogrenci> mList) {
for (int i = 0; i < mList.size(); i++) {
System.out.println(i + " -> " + mList.get(i));
}
}
Kodun çıktısı aşağıdakine benzer olur:
0 -> F. Oğuz ÖZKEROĞLU :: 1988
1 -> Ad SOYAD :: 1985
2 -> İsim SOYİSİM :: 2000
3 -> Deneme YANILMA :: 2011
Şimdi listeyi sıralamaya çalışalım
Collections.sort(mList);
Bu satırda IDE aşağıdaki uyarıyı veriyor:
‘Bound mismatch: The generic method sort(List) of type Collections is not applicable for the arguments (ArrayList). The inferred type Ogrenci is not a valid substitute for the bounded parameter <T extends Comparable<? super T>>’
Biz metoda listeyi sırala diye verdik ama neye göre sıralaması gerektiğini söylemedik. Ad, soyad ve doğum yılına göre sıralanabilir bir liste. Peki böyle durumlarda ne yapacağız? Sıralanacak türü diğer türdaşları ile karşılaştırılabilir bir forma sokacağız. Bunu yapabilmek için ben şöyle bir yöntem kullandım: Collections sınıfının sort metodunun liste ve Comparator türünden nesneleri parametre olarak alan versiyonunu kullandım. Metodu çağırırken Comparator classımı da oluşturdum. Sonunda aşağıdaki gibi bir kod parçası ortaya çıktı:
public class ObjectSort {
/**
* @author Oguz
*/
public static void main(String[] args) {
ArrayList mList = new ArrayList();
mList.add(new Ogrenci("F. Oğuz", "ÖZKEROĞLU", 1988));
mList.add(new Ogrenci("Ad", "SOYAD", 1985));
mList.add(new Ogrenci("İsim", "SOYİSİM", 2000));
mList.add(new Ogrenci("Deneme", "YANILMA", 2011));
// Sıralanmamış listeyi yazdırıyoruz:
System.out.println("Sıralanmamış liste:");
listeyiGoster(mList);
// Listeyi sıralıyoruz
Collections.sort(mList, new Comparator() {
@Override
public int compare(Ogrenci o1, Ogrenci o2) {
String oName1 = o1.getAd();
String oName2 = o2.getAd();
return oName1.compareTo(oName2);
}
});
// Sıralanmamış listeyi yazdırıyoruz:
System.out.println("Sıralanmış liste:");
listeyiGoster(mList);
}
private static void listeyiGoster(ArrayList<Ogrenci> mList) {
for (int i = 0; i < mList.size(); i++) {
System.out.println(i + " -> " + mList.get(i));
}
}
}
‘compare’ metoduna Ogrenci türünde aldığı iki nesnenin adlarını alıp birer String’e atmasını ve karşılaştırmayı bu Stringler arasında yapmasını söyledik. Sonuçta da aşağıdaki gibi bir konsol çıktısı oluştu:
Sıralanmamış liste:
0 -> F. Oğuz ÖZKEROĞLU :: 1988
1 -> Ad SOYAD :: 1985
2 -> İsim SOYİSİM :: 2000
3 -> Deneme YANILMA :: 2011
Sıralanmış liste:
0 -> Ad SOYAD :: 1985
1 -> Deneme YANILMA :: 2011
2 -> F. Oğuz ÖZKEROĞLU :: 1988
3 -> İsim SOYİSİM :: 2000
Metoda aldığı öğrencileri adlarına göre sılaramasını söylediğimiz için konsol çıktısında sıralanmış liste ada göre sıralanmış bir liste oldu. Eğer listenin doğum yılına göre sıralanmasını istiyorsak metodumuzu aşağıdaki gibi değiştirmemiz gerekirdi.
Collections.sort(mList, new Comparator() {
@Override
public int compare(Ogrenci o1, Ogrenci o2) {
Integer oYear1 = o1.getDogumYili();
Integer oYear2 = o2.getDogumYili();
return oYear1.compareTo(oYear2);
}
});
Çıktı da aşağıdaki gibi olur:
Sıralanmamış liste:
0 -> F. Oğuz ÖZKEROĞLU :: 1988
1 -> Ad SOYAD :: 1985
2 -> İsim SOYİSİM :: 2000
3 -> Deneme YANILMA :: 2011
Sıralanmış liste:
0 -> Ad SOYAD :: 1985
1 -> F. Oğuz ÖZKEROĞLU :: 1988
2 -> İsim SOYİSİM :: 2000
3 -> Deneme YANILMA :: 2011
Liste artık dogumYili alanının değerlerine göre sıralı.
Yukarıda yalan – yanlış bilgiler yer alıyor olabilir, okuyanlar böyle bir şeyin farkına varırlarsa lütfen uyarmaktan çekinmesinler.
Android’in veri saklama yöntemleri ile alakalı daha önce Android :: Shared Preferences yazısını yazmıştım. O listedeki external storage cihazın harici hafızasına, yani şimdilik sd karta tekabül ediyor.
Üzerinde çalıştığım projelerin birinde mp3 dosyalarını saklamam gerekiyordu. Sayısı birden fazla ve her birinin ortalama boyutu 10 mb civarında mp3 dosyalarını dahili hafızaya ya da uygulama paketi içinde bir yerlere yazsam kısa süre sonra cihaz kullanılmaz hale gelebilir. Bu durumda çözüm olarak dosyaları sd kart üzerine yazmaya karar verdim (Umarım doğru bir karar vermişimdir :)
Başta direkt sd kart üzerine yazıp uygulamayı çalıştırdım ama kısa süre sonra kart çöplüğe döndü. Her şeyi ana dizin içine atıyordum. İşte tam burda kart üzerinde bir klasör oluşturma ve dosyaları oraya yazma / oradan okuma zorunda kaldım. Bu yazıda da bu olayı nasıl yaptığımı anlatmaya çalışacağım.
Bunun için Java’nın “File” class’ından bir obje yaratıp, parametre olarak yol + klasör ismi verdim ve sonrasında file.mkdir() metodu ile klasörü oluşturdum. Kod aşağıdaki gibi:
File mFile = new File("/sdcard/altKlasor");
mFile.mkdir();
Tabi bu kodun çalışması için yine her zamanki gibi AndroidManifest.xml dosyasına harici hafızaya yazma iznini eklememiz gerekiyor.
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
Bu sayede direkt sd kart altında klasörü oluşturduk. Aşağıda Eclipse’teki File Explorer’ın kod çalışmadan önceki ve sonraki hali var.
Önce:
Sonra:
Kodu çalıştırdık işimizi gördük ama burda ufak bir sıkıntı var. Sd kartın yolunu elle girdik. İlerde yolun değişebilmesi ya da sd kart yerine başka bir harici hafıza kullanılabilmesi durumlarına karşılık daha iyi bir yöntem kullanmak gerekti. Bunun için de harici hafızanın direkt yolunu alan aşağıdaki kodu buldum.
String extStorageDirectory = Environment.getExternalStorageDirectory().toString();
Bu şekilde biraz daha bağımsızlık ve esneklik kazanmış olduk. Dosyayı oluşturan kodun tamamı aşağıdaki gibi şekillendi.
String strNewFolder = "/altKlasor"; String extStorageDirectory = Environment.getExternalStorageDirectory().toString(); File mFile = new File(extStorageDirectory + strNewFolder); mFile.mkdir();
Belki birinin daha işine yarar..
WebView içinde bir web sayfasını göstermek için aşağıdaki kod kullanılıyor.
WebView wv;
wv = (WebView) findViewById(R.id.webview);
wv.loadUrl("http://www.google.com");
Tabi bunu kullanabilmek için uygulamamıza internete erişim iznini vermemiz gerekiyor. Bunun için de AndroidManifest.xml dosyası içinde uygun yere aşağıdaki satırı ekliyoruz.
<uses-permission android:name="android.permission.INTERNET" />
Çalıştırdığımızda aşağıdaki gibi bir görüntü elde ediyoruz.
Buraya kadar bir sıkıntı yok zaten bilinen şeyler. Peki kendi hazırladığımız bir html sayfasını nasıl gösteririz?
Bunun için html içeriğimizi oluşturup bir stringe atıyoruz ve WebView içinde o stringi gösteriyoruz.
String strHtml = "<html><head></head>" + "<body text=\"#444444\" bgcolor=\"#CCCCCC\">" + "<br /><br /><center><h2>" + "Static html content in Android" + "</h2></center></body></html>"; wv.loadData(strHtml, "text/html", "UTF-8");
Artık internet erişimine gerek kalmadığı için Manifest dosyamızdan o izni kaldırabiliriz. Bu string içinde CSS de kullanılabilir. Bunlar yeterli değil, JavaScript de olsun diyorsanız aşağıdaki satırı WebView tanımlamasında sonra eklemeniz gerekir.
wv.getSettings().setJavaScriptEnabled(true);
Örnek uygulamada kullandığım java dosyası:
package com.oguz.example;
import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;
import android.webkit.WebView;
public class WebViewTest extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(
WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
setContentView(R.layout.webwiew_test);
WebView wv = (WebView) findViewById(R.id.webkitWebView1);
String strHtml = "<html><head></head>"
+ "<body text=\"#444444\" bgcolor=\"#CCCCCC\">"
+ "<br /><br /><center><h2>"
+ "Static html content in Android</h2>"
+ "<script type=\"text/javascript\">"
+ "document.write(Date());</script>"
+ "</center></body></html>";
wv.getSettings().setJavaScriptEnabled(true);
wv.loadData(strHtml, "text/html", "UTF-8");
}
}
XML dosyası ise:
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent"> <android.webkit.WebView android:id="@+id/webkitWebView1" android:layout_width="fill_parent" android:layout_height="fill_parent"> </android.webkit.WebView> </LinearLayout>
Android’in iPhone’dan farklı olarak menü tuşuna sahip olması ve bu menü tuşunun işlevini uygulamamız için özelleştirebiliyor olmamız bayağı faydalı bir şey. Yine bir önceki yazımda olduğu gibi projem üzerinde çalışırken kullanmak zorunda kaldığım options menü ve alt menülerden bahsedeceğim.
Peki nedir bu options menü?
Şu yukardaki görselde de görüldüğü üzere cihazın “menu” tuşuna basıldığında aşağıdan açılan menüdür. Seçenek sayısı 6 taneye kadarsa hepsi orda görünür, 6′dan fazla ise 6. seçenek “more” olur ve diğer seçenekleri onu kullanarak görebiliriz. Ayrıca burda görünen menülerin de altında menüler olabilir. Bunlar da submenülerdir. Xml dosyasında tanımlayarak yapmak daha yaygın olsa da ben daha az tercih edilen yöntemle yapacağım. Bunun için eleştiriye açığım tabi.
Öncelikle menünün olmasını istediğimiz Activity’nin onCreateOptionsMenu() metodunu override etmemiz gerekiyor. İçerisine de menü elemanlarını eklememiz lazım. Bunların da alt menülerinin olabileceğini görelim.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
SubMenu mMenu = menu.addSubMenu("Seçenek 0");
mMenu.add(1, 11, 0, "Alt seçenek 1");
mMenu.add(1, 12, 0, "Alt seçenek 2");
mMenu.add(1, 13, 0, "Alt seçenek 3");
mMenu.add(1, 14, 0, "Alt seçenek 4");
menu.add(0, 2, 0, "Seçenek 1");
menu.add(0, 3, 0, "Seçenek 2");
menu.add(0, 4, 0, "Seçenek 3");
menu.add(0, 5, 0, "Seçenek 4");
menu.add(0, 6, 0, "Seçenek 5");
return true;
}
Activity içine yukardaki kodu eklediğimizde onCreateOptionsMenu() metodunu override etmiş oluyoruz ve içine 1 container menü ile 5 tane de seçenek eklemiş oluyoruz. Container menü diye bir terim yok belki de onu ben uydurdum ama işlev olarak benziyorlar çünkü ilk seçenek (Seçenek 0) 4 ayrı alt seçenek içeriyor. Menüye eleman eklerken 4 parametre kullandım. Bunları da aşağıdaki görsel özetliyor.
Uygulamayı bu haliyle çalıştırıp cihazın/emülatörün “menü” tuşuna bastıktan sonra aşağıdakine benzer bir görüntü elde etmemiz gerekir.
Sıfırıncı seçeneği seçtikten sonra da aşağıdaki gibi.
Menümüzü ve alt menüsünü görüntülemede sıkıntı yok. Şimdi bu seçeneklerden herhangi biri seçildiğinde Android’e ne yapması gerektiğini söyleyelim. Bunun için de onOptionsItemSelected() metodunu override etmemiz gerekecek. Aşağıdaki kod ile de bunu yapalım.
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case 11:
secenek11Tiklandi();
return true;
case 12:
secenek12Tiklandi();
return true;
case 13:
secenek13Tiklandi();
return true;
case 14:
secenek14Tiklandi();
return true;
case 2:
secenek2Tiklandi();
return true;
case 3:
secenek3Tiklandi();
return true;
case 4:
secenek4Tiklandi();
return true;
case 5:
secenek5Tiklandi();
return true;
case 6:
secenek6Tiklandi();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
Bundan sonra da artık gidip aşağıdaki metodları oluşturmalı ve içeriğini ne yapılmasını istediğimiz şekilde doldurmalıyız:
- secenek11Tiklandi()
- secenek12Tiklandi()
- secenek13Tiklandi()
- secenek14Tiklandi()
- secenek2Tiklandi()
- secenek3Tiklandi()
- secenek4Tiklandi()
- secenek5Tiklandi()
- secenek6Tiklandi()
Android veri depolama için birkaç farkı yöntem sunuyor. Bunları kendi sitesinde şöyle sıralamış:
- Shared Preferences: Store private primitive data in key-value pairs.
- Internal Storage: Store private data on the device memory.
- External Storage: Store public data on the shared external storage.
- SQLite Databases: Store structured data in a private database.
- Network Connection: Store data on the web with your own network server.
Database kadar olmasa da shared preferences ufak tefek veri depolayıp/erişmek için kullanılası bir şey. Öyle büyük verilerle uğraşmadıkça database yerine tercih edilebilir.
Hash table yapısındaki gibi key-value prensibi ile çalışıyor farklı olarak yalnızca primitive tipler için kullanılabiliyor. Saklayabildiği tipler şunlar:
- boolean
- float
- int
- long
- string
Çalıştığım projede böyle bir şey kullanma ihtiyacı duymuştum. Biraz araştırdıktan sonra işimi gördüm ama buraya da yazayım ki belki başkalarının da işine yarar bir gün.
Örnek bir uygulama üzerinde nasıl olacağını görelim. Öncelikle uygulamanın paylaşılan tercihlerine (bu şekilde çevirsem problem olmaz umarım) erişmek ve eğer daha önceden yoksa bir xml dosyası oluşturmamız gerekir. Verilerin yazıldığı dosya bir xml dosyası. Bunun için aşağıdaki kodu kullanabiliriz:
SharedPreferences mSharedPrefs = getSharedPreferences("xmlFile",
MODE_PRIVATE);
İlk parametre oluşacak dosyanın ismini, ikincisi de hangi modda olacağını belirtiyor. MODE_PRIVATE ile bu dosyanın sadece bizim uygulamamız tarafından erişilebileceğini belirttik. Bundan sonraki adım da dosyayı editlemek için erişmemiz gerekir. Aşağıdaki satır ile de bunu sağlıyoruz.
SharedPreferences.Editor mPrefsEditor = mSharedPrefs.edit();
Artık dosyaya ulaştık. Buraya yukarda da belirttiğim gibi boolean, float, int, long ve/veya string veriler yazıp/okuyabiliriz. Yazmak için put, almak için de get metodları [putString(), getBoolean()...] zaten geliyor.
Örnek uygulamamızda, uygulamanın kaç defa çalıştığını ekranda göstermek istediğimizi düşünelim. Bunun için bir sayaç oluşturalım ve bu değeri paylaşılan tercihlerden okuyalım. Daha sonra da bir textView ile ekranda gösterelim.
int mCounter = mSharedPrefs.getInt("counter", 0);
mCounter değişkenimize xmlFile içindeki “counter” isimli anahtarın değerini atıyoruz. getInt()[ve diğer getXXX] metodlarının aldığı ikinci parametre de default değer. Yani xml dosyası ortada yoksa ya da herhangi bir şekilde ordaki değeri alamazsak, default değerimiz geri dönüyor. Ayrıca dosyadan değer okumak için bir önceki satırdaki gibi editör oluşturmaya gerek yoktu. Editörü dosyaya yazmak için kullanacağız. Satırlar yer değişse ya da ikinci satır aradan çıksa da uygulama şimdilik çalışır.
Uygulamanın daha önce kaç defa çalıştırıldığını görmek için de aşağıdaki kodu yazıyoruz. Daha önceden main.xml içinde tanımladığımız textView nesnesinin text özelliğini, sayacımızın değeri ile güncelliyoruz.
TextView tv = (TextView) findViewById(R.id.tvSampleTv);
tv.setText("Uygulama daha önce " +String.valueOf(mCounter) + " defa çalıştırıldı.");
Uygulamamızı şimdi çalıştırırsak aşağıdakine benzer bir görüntü elde etmiş olmamız lazım.
Benim bu örnekte kullandığım main.xml de aşağıdaki gibi.
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/tvSampleTv" android:textStyle="bold" android:textColor="#FFFFFF" android:layout_gravity="center"></TextView> </LinearLayout>
Sayfamız görüntülendiğine göre artık uygulamamız bir defa daha çalışmış oldu. Demek ki artık sayacı artırmamız gerekecek. Bunun için de aşağıdaki satırları yazalım.
mPrefsEditor.putInt("counter", ++mCounter);
mPrefsEditor.commit();
Nasıl database bağlantısı yapıp işlerimizi hallettikten sonra bağlantıyı kapatıyorsak, dosya açıp yazdıktan sonra dosyayı kapatıyorsak bunda da benzer bir durum (ama aynı değil tabi ki, sadece unutulmaması gereken bir şey olduğu için bu benzetmeleri yaptım. İntegral sınavlarındaki +c kadar önemli vallahi :)) olaraktan yaptıklarızı işlememiz lazım. commit() bunun için kullanıldı.
Uygulamayı bu haliyle çalıştırdığımızda yine ilk ekran görüntüsü gelecek. Yeni halini ilk defa çalıştırmış oluyoruz çünkü. Tekrar çalıştırdığımızda aşağıdaki,
üç defa daha çalıştırdıktan sonra da aşağıdaki görüntüye benzer şeyler görünmesi lazım.
Uygulamanın class kodu da aşağıdaki gibi şekillendi.
package com.oguz.example;
import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.widget.TextView;
public class SharedPrefsExample extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
SharedPreferences mSharedPrefs = getSharedPreferences("xmlFile",
MODE_PRIVATE);
SharedPreferences.Editor mPrefsEditor = mSharedPrefs.edit();
int mCounter = mSharedPrefs.getInt("counter", 0);
TextView tv = (TextView) findViewById(R.id.tvSampleTv);
tv.setText("Uygulama daha önce " + String.valueOf(mCounter)
+ " defa çalıştırıldı.");
mPrefsEditor.putInt("counter", ++mCounter);
mPrefsEditor.commit();
}
}
Şimdi bu uygulamayı yaptık da ne oldu? Evet pek bi ekşın yok ortada çünkü örnek seçimini pek sağlıklı yapmadım. Seçtiğim örnek anlatmak istediğim olaya pek uygun değil ama o kısmı da burda anlatsam herhalde eksiği tamamlarım. Uygulamada tek activity olduğu için pek bir yararını göremedik ama uygulamamızın içindeki tüm classlardan bu özelliklere erişip / değişiklik yapabileceğimizi bilmemiz belki getirdiği kolaylığı farketmemizi sağlayabilir. Üstelik ram gibi program boyunca kalıp tekrar başlatıldığında da kaybolmuyor. Uygulama cihazda bulunduğu sürece değerler korunuyor. Belki bu açıklama örnek seçimimdeki açığı biraz kapatmıştır :)
Oluşan xml dosyamızı da /data/data/paket.adi/shared_prefs altında bulabilir. En başta belittiğimiz moda göre erişim hakları düzenleniyor.
Netbeans’in sitesindeki web service tutorials sayfasında [0], Software as a Service (SaaS) kategorisinde bulunan Creating a Graphical Client for Twitter [1] isimli dökümanda anlatılanları yapmaya çalıştım ve görüntüsü ile işlevi ordakine benzer bir şey ortaya çıktı.
Bu yazımda, bu iş için uğraşırken neler yaptığımdan bahsedeceğim (anladığım kadarıyla).
Olası yanlış eylem ve anlatımlar için baştan uyarımı yapayım.
Başlamadan önce eğer bir twitter hesabınız yoksa twitter.com’a gidip bir hesap edinin.
Sayfada dediğine göre twitter hesabının yanında Netbeans 6.5, 6.7 ya da 6.8 sürümlerinden biri ile Java Development Kit (JDK) V6 ya da V5′e de ihtiyacımız olacak. Ayrıca “web servisi ne demek?” diyenler olursa bu yazıdan önce wiki’den [2] web servisine baksa hoş olur.
Arayüzün tasarlanması
Tasarlanacak ekranda genel twitlerin akışının olacağı bir liste, kişinin kullanıcı resmi ve durumunu okuyup istediğinde güncellemesi için bir metin kutusuyla bir buton olacak. Şimdi projeyi oluşturalım.
Bunun için; Netbeans’i açıp, File -> New Project -> Java -> Java Application yolunu izleyelim.
Daha sonra projemize bir isim verelim ve Create Main Class seçeneğinin başındaki tick’i kaldıralım. Ben ismi TwitterClient olarak vermişim.
Buraya kadar herhangi bir problem olmadıysa şu aşağıdakine benzer bir görüntü ortaya çıkmış olmalı.
IDE yeni bir proje oluşturacaktır. Şimdi projeye bir paket ekleyelim ve o pakete de bir JFrame Form ekleyelim.
Bunun için paket üzerine sağ tıkladıktan sonra New -> JFrame Form ya da New -> Other -> Swing GUI Forms -> JFrame Form yolu izlenir.
Bu da yapıldıysa karşımızda aşağıdakine benzer bir ekran olmalı.
Finish butonundan sonra IDE yaratılan formu tasarım kipinde açacaktır. Sağ taraftaki palet kısmında da sürükle bırak ile kullanılabilecek tüm Swing bileşenleri bulunmaktadır. Şimdi o paletten bir buton (jButton1) süreükleyip formun üzerine bırakalım. Daha sonra botun özelliklerinden ismi ve iconu değiştirilebilir. Bu buton, metin kutusuna yazdıklarımızı kullanarak durumumuzu güncellemek için kullanacağımız buton.
Butondan sonra bir tane de metin kutusuna ihtiyacımız var. Bunun için de paletten bir tane Text Field (jTextField1) sürükleyip butonun yanına bırakalım.
Buton ve metin kutusundan sonra da kullanıcı resmi için bir tane Label (jLabel1) sürükleyip metin kutusunun yanına bırakıyoruz. Üzerinde sağ tıkladıktan sonra Maximum Size, Minimum Size ve Preferred Size özelliklerini [48, 48] olacak şekilde değiştiriyoruz. Çünkü görünen resim boyutları bu kadar olacak, daha büyük olması sadece gereksiz boşluklara yol açacaktır.
Şimdi de twitlerin listesi için bir adet Scroll Pane ve içine de bir adet List sürükleyip bırakıyoruz. Daha sonra da formu kaydediyoruz.
Tasarımda kullanılacak elemanlar bu kadar. Eğer herhangi bir problem olmadıysa görüntü şuna benzer olacaktır:
Kullanıcı Durumunu Gösterme
Arayüz tasarımından sonra kod kısımlarına başlayabiliriz. Kullanıcı durumunun gösterilmesi için yapılması gerekenleri bu başlık altında yazalım.
TwitterJFrame.java dosyasını açıp, tasarım kısmından kod kısmına geçelim ve main () metodunun yerini bulup üzerinde birkaç satır boşluk bırakalım.
Burda da aşağıdaki gibi yeni bir metod tanımlayalım ;
private void initUserInfo() {
}
Şimdi IDE’nin Services penceresini açalım. Web Services altında Twitter > What Are You Doing Service > [statuses] > [user_timeline.{format}] > getUserTimeline yolunu izleyelim. Orda bulunan getUserTimeline parçasını yukarda oluşturduğumuz initUserInfo() metodunun içine sürükleyip bırakalım. Karşımızda Customize GET SaaS Service penceresi açılacaktır. O pencerede bulunan count alanının default değerini 1 yapıp diğer default değerleri değiştirmeden devam edelim.
IDE bizim için initUserInfo() metodunun içinde kod üretecektir. Ayrıca org.netbeans.saas ve org.netbeans.saas.twitter paketleri ile içlerinde bazı dosyalar oluşturacaktır. Eğer kod düzensiz görünüyorsa editör içinde sağ tık -> format ya da Alt + Shift + F ile otomatik düzenleme yapılabilir.
Durumdan rahatsız olmayanlar için buna da gerek yok tabi ki :) Oluşturulan bu koddaki if () bloğunun içine aşağıdaki kodu eklemeliyiz :
StatusType st = resultObj.getStatus().get(0);
jTextField1.setText(st.getText().trim());
UserType user = st.getUser();
String iconSrc = user.getProfileImageUrl();
URL iconUrl = new URL(iconSrc);
ImageIcon icon = new ImageIcon(iconUrl, user.getScreenName());
jLabel1.setIcon(icon);
Eklediğimiz bu kod kullanıcı resmimiz ile mevcut durumumuzu jLabel1 ve jTextField1 içinde görüntülememizi sağlamak içindi. Tabi çalışması için IDE’nin yönlendirdiği gerekli importlar yapılmalı. Bunun için Ctrl + Shift + i kısayolu da kullanılabilir. Gerekli importlar da yapıldıktan sonra constructor bulunup içine initUserInfo(); satırı da eklenmelidir.
public class TwitterJFrame extends javax.swing.JFrame {
/** Creates new form TwitterJFrame */
public TwitterJFrame() {
initComponents();
initUserInfo();
}
Projeyi kaydedip çalıştırdığımızda aşağıdakine benzer bir şeyler ortaya çıkmalı. Bu arada 16 Mayıs 2010′da hayata gözlerini yuman müzisyen Ronnie James DIO’nun da ismi bu yazıda yer almış oldu..
Bu sıra ile gidilirse proje istediğimiz gibi çalışmayacaktır çünkü herhangi bir yere kullanıcı adı ve parola girmedik. Bu bilgileri yazacağımız yer ise org.netbeans.saas.twitter içindeki twitterwhatareyoudoingserviceauthenticator.properties dosyası.
Netbeans sayfasına Windows XP ve Linux için login işlemlerinde problemler çıkacağı yazıyordu.
Ben Pardus 2009.1 kullanıyorum ve bende de bahsettiği problemler çıktı. Çözümü de aynı sayfada verilmiş. Çözümü için örnek projede [3] bulunan twitterclient.AuthDialog.java dosyasını kendi twitterclient paketimize kopyalamamızı ve org.netbeans.saas.twitter altındaki TwitterWhatAreYouDoingServiceAuthenticator.java dosyasını kendimizinkinin yerine koymamızı öneriyordu. Önerdikleri değişiklikleri yaptım ve proje sorunsuz çalıştı.
Durum Güncelleme Metodunun Eklenmesi
Güncelleme butonumuzun metin kutusundan aldığı metni kullanarak durumumuzu güncellemesini sağlamak için butona çift tıklayalım. IDE bizim için jButton1ActionPerformed () metodunu oluşturacaktır. Şimdi yeniden Services penceresinden Web Services -> Twitter -> WhatAreYouDoingService -> Statuses -> [update.{format}] -> updateStatus yolunu izleyelim. Daha sonra da burada bulunan updateStatus metodunu sürükleyip jButton1ActionPerformed() metodunun gövdesine bırakalım. Çıkan penceredeki öntanımlı değerleri kabul edip devam edelim.
Oluşturulan kod içindeki try bloğundaki
String status = "";
satırını
String status = jTextField1.getText().trim();
satırı ile değiştirdikten sonra projeyi kaydedip çalıştıralım. Formumuz artık durum güncellemesi yapabilmektedir.
Kullanıcı İsimlerini ve Durumlarını Formda Gösterme
Twitlerin otomatik görünmesi için bir Timer nesnesine ihtiyacımız olacak. Bunun için consructordaki initComponents(); satırının üzerine Timer nesnesi için bir satır daha eklenir.
public class TwitterJFrame extends javax.swing.JFrame {
/** Creates new form TwitterJFrame */
public TwitterJFrame() {
Timer t = new Timer("Twitter Updater`", false);
initComponents();
initUserInfo();
}
Gerekli importlar yapıldıktan sonra consructor şöyle olacaktır :
public class TwitterJFrame extends javax.swing.JFrame {
/** Creates new form TwitterJFrame */
public TwitterJFrame() {
Timer t = new Timer("Twitter Updater`", false);
t.scheduleAtFixedRate(new TimerTask() {
}, 1500, 75000);
initComponents();
initUserInfo();
}
Sonra da consructordan önce
private DefaultListModel statuses = new DefaultListModel();
satırlarnı koda eklemeliyiz. Gerekli importlar ve eklenen otomatik kodlardan sonra elimizde şu kodlar yer almalı :
public class TwitterJFrame extends javax.swing.JFrame {
private DefaultListModel statuses = new DefaultListModel();
/** Creates new form TwitterJFrame */
public TwitterJFrame() {
Timer t = new Timer("Twitter Updater`", false);
t.scheduleAtFixedRate(new TimerTask() {
@Override
public void run(){
}
}, 1500, 75000);
initComponents();
initUserInfo();
}
Şimdi yeniden Services penceresine açalım ve Web Services -> Twitter -> What Are You Doing Service -> [statuses] -> [public_timeline.{format}] -> getPublicTimeline yolunu izleyelim. getPublicTimeline metodunu t.scheduleAtFixedRate içindeki run() metodunun gövdesine sürükleyip bırakalım. Açılan pencerede yine default değerleri kabul edip devam edelim. IDE’nin bizim için oluşturduğu kod içindeki if() bloğunun içine(en alta), şu aşağıdaki kodu ekleyelim:
for (final StatusType st : result2Obj.getStatus()) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
statuses.addElement(st);
}
});
}
Gerekli kütüphaneler import edildikten sonra genel akıştaki twitlerin alınması işi tamamlanmış oluyor. Şimdi bu twitleri listeleyebilmek için bir
nesne oluşturalım.
Bunun için en başta oluşturduğumuz twitterclient paketinde sağ tıkladıktan sonra New > JPanel Form yoluyla bir JPanel Form ekleyelim. Açılan sayfada JPanel’e Item ismini verelim ve kaydedelim.
Açılan tasarım ekranında paletten bir Label ve Text Pane sürükleyip formun üzerine bırakalım. Label kullanıcı ismini, Text Pane de o kullanıcının twitini gösterecek. Daha sonra tasarım kısmından çıkıp kod kısmına geçildiğinde:
public class Item extends javax.swing.JPanel {
satırına implements ListCellRenderer ifadesi eklenir.
public class Item extends javax.swing.JPanel implements ListCellRenderer {
Bu işlemden sonra aşağıdaki bloğa da yeni satırlar ekleyerek o hale getirelim ve gerekli kütüphaneleri import edelim:
public Component getListCellRendererComponent(JList list, Object value, int index, boolean sel, boolean focus) {
StatusType st = (StatusType) value;
jTextPane1.setText(st.getText());
jLabel1.setText("<html>" + st.getUser().getScreenName() + "</html>");
return this;
}
Artık Item classımız da hazır. Şimdi jFrame’e geri dönelim ve tasarım kipinde açalım. JList üzerinde sağ tıklayıp Properties penceresini açalım.
model özelliğini seçelim ve Ctrl + Space tuşlarına birlikte bastığımızda yeni bir pencere açılacak.
“Set jLlist1′s model property using:” menüsünden Custom Code seçeneğini seçelim ve açılan metin kutusuna “statuses” yazalım ve devam edelim.
Properties penceresindeki cellRenderer özelliğini seçelim ve yine Ctrl + Space tuşlarına birlikte basalım. Açılan pencerede karşımıza çıkan “Set jList1′s cellRenderer property using:” menüsünden Custom Code seçeneğini seçtikten sonra metin kutusune new Item() yazıp devam edelim.
İşte bu kadar!
Projeyi kaydedip çalıştırdığımızda Web Services -> Twitter -> What Are You Doing Service -> [statuses] -> [public_timeline.{format}] -> getPublicTimeline kullandığımız için takip etmediğimiz kişilerin de twitlerini görüntülüyor olacağız. Daha edepli şeyler görmeyi umardım :)
Peki sadece takip ettiğimiz kişilerin twitlerini görüntülemek için ne yapmalıyız? Çok fazla bir değişiklik yok aslında. Yukarıda
Web Services -> Twitter -> What Are You Doing Service -> [statuses] -> [public_timeline.{format}] -> getPublicTimeline yolunu izlemiştik.
Şimdi sadece o yolu Web Services -> Twitter -> What Are You Doing Service -> [statuses] -> [friends_timeline.{format}] -> getFriendsTimeline yoluyla değiştireceğiz. O değişiklikten sonra da aşağıdaki gibi bir ekran elde ettim.
Takip ettiklerim inşallah telif hakkı diye koşmazlar gelecekte arkamdan :)
Bir hazır çalışmanın daha sonuna geldik. İleride belki bir şeyler öğrenirim de kendi çalışmalarımı burda yazarım. Şimdilik umuduyla yaşayıp sıfır uğraşla devam edelim..
[0] -> http://netbeans.org/kb/trails/web.html
[1] -> http://netbeans.org/kb/docs/websvc/twitter-swing.html
[2] -> http://en.wikipedia.org/wiki/Web_service
[3] -> http://www.oguzozkeroglu.com/download/TwitterSwingClient.zip
-> http://netbeans.org/files/documents/4/2432/TwitterSwingClient.zip