Veri olmayan List görünümünde ekrana "Veri bulunamadı" gibi mesaj ver

Resimi sonradan yükledim ama yazının sonuna geldiğinizde daha anlamlı olacaktır.


ListActivity sınıfından türemiş bir sınıfınız ile içinde verileri göstereceğiniz bir ekran oluşturmak isteyelim.
Kıymetli noktalardan biri: ListActivity sınıfının adından da anlaşılacağı gibi Activity sınıfından türemiş olduğunu görebilmek.
İkinci kıymetli nokta ise Activity sınıfının Context sınıfından türetilmiş olduğunu bilmek.
Üçüncü ve bunların birleşim kümesi ise; this kelimesini Context parametre alabilen metotlara gönderebilmenizin her ne kadar ilk bakışta ListActivity sınıfından türetilen nesneyi (çalışan ekranınızı) işaret etsede aslında ListActivity : Activity : Context sınıflarını işaret ettiğini bilmeniz.

Şimdi gelelim Liste görünümünü sağlayan aşağıdaki LAYOUT dosyası olan liste.xml dosyamıza.

Öncelikle bu tip dosyaların isimleri, büyük harf içermiyor olmalı(ilk zamanlar "bu ne hatası" diye epeyce bakmıştım console da çıkan res\layout\listeCem.xml: Invalid file name: must contain only [a-z0-9_.] hatasına).

Bu layout içinde LinearLayout > ListView , TextView xml etiketleri var. Bu etiketlerin andorid tarafından anlamlarını biliyorsunuz.
LinearLayout : Doğrusal olarak, bileşenleri içeren kapsayıcı bileşen (Dilerseniz içindeki bileşenleri yukarıdan aşağı doğru(orientation:vertical), dilerseniz soldan sağa (orientation:horizontal) sıralar)

ListView, TextView : View sınıfından türetildiklerini farketmişsinizdir. ListView, verilerimizi satır satır gösterecek bileşen. Bu bileşene ayrıca bir template_row.xml adında bir dosya ile her satırın nasıl görünmesi gerektiğini bildireceğiz. TextView ise veri kümemizde(dataset) hiç gösterilecek bir satır yoksa burada "Hacı hiç veri yokki göstereyim" gibi bir metin göstereceğiz.

liste.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   >
<ListView
    android:id="@+id/android:list"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    />
<TextView
    android:id="@+id/android:empty"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:text="Gösterilecek bir şey yok...!"/>
</LinearLayout>

template_row.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="match_parent" 
 android:layout_height="match_parent">
 
 <TextView 
  android:id="@+id/tvTagListTitle"
  android:layout_width="wrap_content" 
  android:layout_height="wrap_content" />
  
 <TextView 
  android:id="@+id/tvTagListTag" 
  android:layout_width="wrap_content"
  android:layout_height="wrap_content" />
</LinearLayout>

template_row.xml dosyamız liste şeklinde göstereceğimiz verilerin her bir satırının nasıl olması gerektiğini belirttiğimiz xml dosyası.
Bu dosyayı ArrayAdapter sınıfından türettiğimiz InformationTagsAdapter sınıfında kullanacağız.

ArrayAdapter : Sınıfının (somut -class- ya da özet -abstract- mi bilemedim) adından bir ARRAY (diziyi)'i bir şeye adapte(ADAPTER) edecek.

InformationTagsAdapter.java

// ArrayAdapter sınıfından türettiklerimi farklı bir pakette tutmak istediğim için aşağıdaki satırı ekledim.
package cem.examples.reminder.adapters;

import java.util.ArrayList;
import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import cem.examples.reminder.Information;
import cem.examples.reminder.R;

public class InformationTagsAdapter extends ArrayAdapter<Information> {
 Activity    activityCtx;
 ArrayList<Information> infos;

// Yapıcı metoduma Context tipinde parametre geçirmem gerekiyor.
// Böylece bu adapter sınıfının kullanıldığı Context'i ArrayAdapter sınıfının yapıcı metoduna geçirebileceğim
// Ayrıca veri kümemi de yapıcı metot ile geçiriyorum ki ArrayAdapter sınıfnın yapıcısına geçsin ve veri bağlama(data binding) 
// işine başlansın. 
// Eğer küme boşsa xml içindeki android:id="@+id/android:empty" özellikli (attribute) xml etiketi
// "Gösterilecek bir veri yok" mesajını göstersin.
 public InformationTagsAdapter(Activity _context, ArrayList<Information> _infos) {
  super(_context, R.layout.template_row, _infos);
  activityCtx = _context;
  infos = _infos;
 }


// Bu metot ArrayAdapter sınıfından geliyor. Override olduğuna göre ArrayAdapter abstract sınıftır ve bu metot abstract olarak tanımlanmış.
// Bu metoda veri kümesindeki kaçıncı eleman bağlanıyorsa int position parametresi ile,
// View convertView ile de listeye eklenecek satır parametre olarak geçiriliyor.
 @Override
 public View getView(int position, View convertView, ViewGroup parent) {

// Oluşturulacak satır eğer null ise R.layout.template_row ile template_row.xml dosyasının bir örneği LayoutInflater
// tarafından oluşturulur ve içindeki bileşenler tek tek veri kümesindeki, position'ıncı verinin elemanları ile bağlanır.
  View v = convertView;
  if (convertView == null) {
   LayoutInflater inf = (LayoutInflater) activityCtx.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
   v = inf.inflate(R.layout.template_row, parent, false);
  }

  Information info = infos.get(position);
  if (info != null) {

// tvTagListTitle ve tvTagListTag TextView bileşenleri R.layout.template_row diye R.java dosyasında
// değişken olarak oluşturulan ve template_row.xml dosyasını işaret eden dosyada bulunuyorlar.
   TextView tvTitle = (TextView) v.findViewById(R.id.tvTagListTitle);
   TextView tvTag = (TextView) v.findViewById(R.id.tvTagListTag);
   
   if (tvTag != null && tvTitle != null) {
    tvTitle.setText(info.MTitle);
    for (String tag : info.MTags) {
     tvTag.setText(tag);
    }
   }
  }
  return v;
 }
}

Activity ler arasında geçiş

Activity1.java

package cem.examples.activityswitch;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class Activity1 extends Activity implements OnClickListener {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);this.setContentView(R.layout.main);
// ------------------------------------------------------
  Button btn = (Button) findViewById(R.id.button1);
  btn.setOnClickListener(this);
 }

 @Override
 public void onClick(View v) {
  Intent myint = new Intent(v.getContext(),Activity2.class);
  startActivityForResult(myint, 0);
 }
}

Activity2.java

package cem.examples.activityswitch;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;
import android.widget.LinearLayout;

public class Activity2 extends Activity implements OnClickListener {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  this.setContentView(R.layout.activite2);
// --------------------------------------------------------------
  Button btnPre = new Button(this);
  btnPre.setText("Geriiiii");
  // Butonun layout üzerinde alacağı görünüm parametreleri
  LayoutParams params = new LayoutParams(
    LayoutParams.MATCH_PARENT,
    LayoutParams.MATCH_PARENT);
// --------------------------------------------------------------
  LinearLayout layout = (LinearLayout) findViewById(R.id.lout);
  layout.addView(btnPre, params);
// --------------------------------------------------------------
  // Önceki aktiviteye gidelim.
  btnPre.setOnClickListener(this);
 }

 @Override
 public void onClick(View v) {
  // Call this to set the result that your activity will return to its caller.
  setResult(RESULT_OK);
  // Call this when your activity is done and should be closed
  finish();
 }
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="cem.examples.activityswitch" android:versionCode="1"
 android:versionName="1.0">
 <uses-sdk android:minSdkVersion="8" />

 <application android:icon="@drawable/icon" android:label="@string/app_name">

  <activity android:name=".Activity1" android:label="Activite Etiketi"
   android:screenOrientation="portrait">
   <intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
   </intent-filter>
  </activity>
  <activity android:name=".Activity2"></activity>
 </application>
</manifest>

Activity ve AndroidManifest.xml ilişkisi ve No Launcher activity found! hatası

Proje oluşturulurken "Main Activity" oluşturulmamışsa AndroidManifest.xml dosyası aşağıdaki gibidir.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="cem.examples.activityswitch" android:versionCode="1"
 android:versionName="1.0">
 <uses-sdk android:minSdkVersion="8" />

 <application android:icon="@drawable/icon" android:label="@string/app_name">

 </application>
</manifest>

Buna göre program AVD ye yüklenirken Console çıktısı şöyle olur:

...
[2011-05-28 13:31:16 - switchActivity] Android Launch!
[2011-05-28 13:31:16 - switchActivity] adb is running normally.
[2011-05-28 13:31:16 - switchActivity] No Launcher activity found!
[2011-05-28 13:31:16 - switchActivity] The launch will only sync the application package on the device!
[2011-05-28 13:31:16 - switchActivity] Performing sync
...

AndroidManifest.xml dosyasına başlatılacak Activity sınıfından türetilmiş bir ***.java dosyasının sınıfını LAUNCH edilecek MAIN action olarak belirtmemiz gerekiyor. Bunu da aşağıdaki <activity> xml elemanını <application> xml elemanının içine koyarak yaparız:

<activity android:name=".Activity1" android:label="Activite Etiketi" android:screenOrientation="portrait">
 <intent-filter>
  <action android:name="android.intent.action.MAIN" />
  <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
</activity>

Sonuç:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="cem.examples.activityswitch" android:versionCode="1"
 android:versionName="1.0">
 <uses-sdk android:minSdkVersion="8" />

 <application android:icon="@drawable/icon" android:label="@string/app_name">

  <activity android:name=".Activity1" android:label="Activite Etiketi"
   android:screenOrientation="portrait">
   <intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
   </intent-filter>
  </activity>

 </application>
</manifest>

Android: Aktiviteler arası geçiş

<?xml version="1.0" encoding="utf-8" ?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="org.example.sudoku" android:versionCode="1" android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true">
        <activity android:name=".Sudoku" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".About" android:label="@string/about_title" android:theme="@android:style/Theme.Dialog" />
        <activity android:name=".Prefs" android:label="@string/settings_title" />
    </application>
    <uses-sdk android:minSdkVersion="3" android:targetSdkVersion="8" />
</manifest>

application etiketinin alabildiği özellikler:
http://developer.android.com/guide/topics/manifest/application-element.html

1. 
   Yukarıdaki manifest.xml içinde dikkat edilmesi gereken özellik
   "android:debuggable"
   

   
   Whether or not the application can be debugged, even when running on a device in user mode — "true" if it can be, and "false" if not. The default value is "false".
   

   
   
2. 
   Diğer dikkat edilmesi gereken ise aktivitenin (yani gösterilecek aktif edilecek aktivitenin) android'in varsayılan teması ile şenlenmesi:
   
   <activity android:name=".about" android:label="Programa dair :)"></activity>
   
   
   
   <activity android:name=".about" android:label="Programa dair :)" android:theme="@android:style/Theme.Dialog" ></activity>
   
   

Anatomy of an Android Application

Ref: http://www.anddev.org/novice-tutorials-f8/anatomy-of-an-android-application-t21.html


There are four building blocks to an Android application:

1. Activity


2. Intent Receiver


3. Service


4. Content Provider

Not every application needs to have all four, but your application will be written with some combination of these.

Once you have decided what components you need for your application, you should list them in a file called AndroidManifest.xml. This is an XML file where you declare the components of your application and what their capabilities and requirements are. See the Android manifest file documentation for complete details.

Activity

Activities are the most common of the four Android building blocks. An activity is usually a single screen in your application. Each activity is implemented as a single class that extends the Activity base class.

public class aktiviteAdi extends Activity {

Your class will display a user interface composed of Views and respond to events. Most applications consist of multiple screens. For example, a text messaging application might have one screen that shows a list of contacts to send messages to, a second screen to write the message to the chosen contact, and other screens to review old messages or change settings. Each of these screens would be implemented as an activity. Moving to another screen is accomplished by a starting a new activity. In some cases an activity may return a value to the previous activity -- for example an activity that lets the user pick a photo would return the chosen photo to the caller.

When a new screen opens, the previous screen is paused and put onto a history stack. The user can navigate backward through previously opened screens in the history. Screens can also choose to be removed from the history stack when it would be inappropriate for them to remain. Android retains history stacks for each application launched from the home screen.

Intent and Intent Filters

Android uses a special class called an Intent to move from screen to screen. An intent describes what an application wants done. The two most important parts of the intent data structure are the action and the data to act upon. Typical values for action are MAIN (the front door of the activity), VIEW, PICK, EDIT, etc. The data is expressed as a URI. For example, to view contact information for a person, you would create an intent with the VIEW action and the data set to a URI representing that person.

There is a related class called an IntentFilter. While an intent is effectively a request to do something, an intent filter is a description of what intents an activity (or intent receiver, see below) is capable of handling. An activity that is able to display contact information for a person would publish an IntentFilter that said that it knows how to handle the action VIEW when applied to data representing a person. Activities publish their IntentFilters in the AndroidManifest.xml file.

Navigating from screen to screen is accomplished by resolving intents. To navigate forward, an activity calls startActivity(myIntent). The system then looks at the intent filters for all installed applications and picks the activity whose intent filters best matches myIntent. The new activity is informed of the intent, which causes it to be launched. The process of resolving intents happens at run time when startActivity is called, which offers two key benefits:

* Activities can reuse functionality from other components simply by making a request in the form of an Intent
* Activities can be replaced at any time by a new Activity with an equivalent IntentFilter

Intent Receiver

You can use an IntentReceiver when you want code in your application to execute in reaction to an external event, for example, when the phone rings, or when the data network is available, or when it's midnight. Intent receivers do not display a UI, although they may use the NotificationManager to alert the user if something interesting has happened. Intent receivers are registered in AndroidManifest.xml, but you can also register them from code using Context.registerReceiver(). Your application does not have to be running for its intent receivers to be called; the system will start your application, if necessary, when an intent receiver is triggered. Applications can also send their own intent broadcasts to others with Context.broadcastIntent().
Service

A Service is code that is long-lived and runs without a UI. A good example of this is a media player playing songs from a play list. In a media player application, there would probably be one or more activities that allow the user to choose songs and start playing them. However, the music playback itself should not be handled by an activity because the user will expect the music to keep playing even after navigating to a new screen. In this case, the media player activity could start a service using Context.startService() to to run in the background to keep the music going. The system will then keep the music playback service running until it has finished. (You can learn more about the priority given to services in the system by reading Lifecycle of an Android Application.) Note that you can connect to a service (and start it if it's not already running) with the Context.bindService() method. When connected to a service, you can communicate with it through an interface exposed by the service. For the music service, this might allow you to pause, rewind, etc.

Content Provider

Applications can store their data in files, an SQLite database, or any other mechanism that makes sense. A content provider, however, is useful if you want your application's data to be shared with other applications. A content provider is a class that implements a standard set of methods to let other applications store and retrieve the type of data that is handled by that content provider.

To get more details on content providers, see Accessing Content Providers.

Android Life Cycle