Professional Documents
Culture Documents
2. Android Development Tools 2.1. What are the Android Development Tools? 2.2. Dalvik Virtual Machine 2.3. How to develop Android Applications 3. Android Application Architecture 3.1. AndroidManifest.xml 3.2. R.java, Resources and Assets 3.3. Reference to resources in XML files 3.4. Activities and Layouts 3.5. Activities and Lifecycle 3.6. Context 4. Installation 4.1. Pre-requisites for using a 64bit Linux 4.2. Eclipse and automatic Android SDK 4.3. Manually install Android SDK 4.4. Install a specific Android version 4.5. Android Source Code 5. Android virtual device - Emulator 5.1. What is the Android Emulator? 5.2. Google vrs. Android AVD 5.3. Emulator Shortcuts 5.4. Performance 6. Tutorial: Create and run Android Virtual Device 7. Error handling and typical problems 7.1. Clean Project 7.2. Problems with Android Debug Bridge (adb) 7.3. LogCat 7.4. Emulator does not start 7.5. Error message for @override 7.6. Missing Imports 7.7. Eclipse Tips 8. Your first Android project 8.1. Create Project 8.2. Two faces of things 8.3. Create attributes 8.4. Add UI Elements 8.5. Edit UI properties 8.6. Code your application 8.7. Start Project 9. Starting an deployed application 10. Menus and Action Bar 10.1. Definition of menu entries 10.2. Action bar tabs 10.3. Context menus
converted by Web2PDFConvert.com
11. Tutorial: Menus and Action Bar 11.1. Project 11.2. Add a menu XML resource 12. Preferences 13. Tutorial: Preferences 13.1. Using preferences 13.2. Run 14. Dialogs via the AlertDialog 15. Layout Manager and ViewGroups 15.1. Available Layout Manager 15.2. LinearLayout 15.3. GridLayout 16. ScrollView 17. Fragments 17.1. Overview 17.2. When to use Fragments 18. Fragments Tutorial 18.1. Overview 18.2. Create project 18.3. Create layouts for landscape mode 18.4. Create Fragment classes 18.5. Create layouts for landscape mode 18.6. Activities 18.7. Run 19. DDMS perspective and important views 19.1. DDMS - Dalvik Debug Monitor Server 19.2. LogCat View 19.3. File explorer 20. Shell 20.1. Android Debugging Bridge - Shell 20.2. Uninstall an application via adb 20.3. Emulator Console via telnet 21. Deploy your application on a real device 22. Thank you 23. Questions and Discussion 24. Links and Literature 24.1. Source Code 24.2. Android Resources 24.3. vogella Resources
1. What is Android?
1.1. Android Operation System
Android is an operating system based on Linux with a Java programming interface. The Android Software Development Kit (Android SDK) provides all necessary tools to develop Android applications. This includes a compiler, debugger and a device emulator, as well as its own virtual machine to run Android programs. Android is officially guided by the Open Handset Alliance. In reality Google leads the project. Android allows background processing, provides a rich user interface library, supports 2-D and 3-D graphics using the OpenGL libraries, access to the file system and provides an embedded SQLite database.
converted by Web2PDFConvert.com
Intents are asynchronous messages which allow the application to request functionality from other components of the Android systen, e.g. from Services or Activities. An application can call a component directly (explicit intent) or ask the Android system to evaluate registered components for a certain Intents (implicit intents). For example the application could implement sharing of data via an Intent and all components which allow sharing of data would be available for the user to select. Applications register themselves to an intent via an IntentFilter. Intents allow to combine loosely coupled components to perform certain tasks. BroadcastReceiver can be registered to receives system messages and Intents. BroadcastReceiver will get notified by the Android system if the specified situation happens. For example a BroadcastReceiver could get called once the system completed its boot process or if a phone call is received. Widgets are interactive components which are primary used on the Android homescreen. They typically display some kind of data and allow the user to perform actions via them. For example a Widget could display a short summary of new emails and if the user select a email it could start the email application with the selected email. Android provide much more components but the list above describes the most important ones. Other Android components are "Live Folders" and "Live Wallpapers". Live Folders display data on the homescreen without launching the corresponding application.
converted by Web2PDFConvert.com
Android applications are primary written in the Java programming language. The Java source files are converted to Java class files by the Java compiler. Android provides a tool dx which converts Java class files into a dex (Dalvik Executable) file. All class files of one application are placed in one compressed .dex file. During this conversion process redundant information in the class files are optimized in the .dex file. For example if the same String in different class file is found, the .dex file is stored only once and reference this String in the corresponding classes. .dex files are therefore much smaller in size then the corresponding class files. The .dex file and the resources of an Android project, e.g. the images and XML files are packed into an .apk (Android Package) file. The program aapt (Android Asset Packaging Tool) perform this packaging. The resulting .apk file contains all necessary data to run the Android application and can be deployed to an Android device via the "adb" tool. The Android Development Tools (ADT) allows that all these steps are performed transparent to the user; either within Eclipse or via the command line. If you use the ADT tooling you press a button or run a script and the whole Android application (.apk file) will be created and deployed.
The package attribute defines the base package for the following Java elements. It also must be unique as the Android Marketplace only allows application for a specific package once. Therefore a good habit is to use your reverse domain name as a package to avoid collisions with other developers. android:versionName and android:versionCode specify the version of your application. versionName is what the user sees and can be any string. versionCode must be an integer and the Android Market uses this to determine if you provided a newer version to trigger the update on devices which have your application installed. You typically start with "1" and increase this value by one if you roll-out a new version of your application. The tag <activity> defines an Activity, in this example pointing to the class "de.vogella.android.temperature.Convert". An intent filter is registered for this class which defines that this Activity is started once the application starts (action android:name="android.intent.action.MAIN" ). The category definition category android:name="android.intent.category.LAUNCHER" defines that this application is added to the application directory on the Android device. The @string/app_name value refer to resource files which contain the actual values. This makes it easy to provide different resources, e.g. strings, colors, icons, for different devices and makes it easy to translate applications. The "uses-sdk" part of the "AndroidManifest.xml" defines the minimal SDK version for which your application is valid. This will prevent your application being installed on devices with older SDK versions. defines the minimal SDK version your application is valid for
converted by Web2PDFConvert.com
If you create a new resource, the corresponding reference is automatically created in R.java. The references are static int values, the Android system provides methods to access the corresponding resource. For example to access a String with the reference id R.string.yourString use the method getString(R.string.yourString));. R.java is automatically maintained by the Eclipse development environment, manual changes are not necessary. While the directory res contains structured values which are known to the Android platform the directory assets can be used to store any kind of data. In Java you can access this data via the AssetsManager and the method getAssets().
3.6. Context
The class android.content.Context provides the connections to the Android system. It is the interface to global information about the application environment. Context also provides access to Android Services, e.g. theLocation Service. As Activities and Services extend the class Context you can directly access the context via this.
4. Installation
converted by Web2PDFConvert.com
The following assume that you have already Eclipse installed. For details please see Eclipse Tutorial
Please check your distribution documentation if you are using a different flavor of Linux.
converted by Web2PDFConvert.com
The dialog allows you to install new packages and also allows you to delete them. Select "Available packages" and open the "Third Party Add-ons". Select the Google API 14 (Android 4.0) version of the SDK and press "Install".
Press the "Install" button and confirm the license for all packages. After the installation completes, restart Eclipse.
Alt+Enter Maximizes the emulator. Nice for demos. Ctrl+F11 changes the orientation of the emulator. F8 Turns network on / off.
5.4. Performance
Try to use a smaller resolution for your emulator as for example HVGA. The emulator gets slower the more pixels its needs to render as it is using software rendering. Also if you have sufficient memory on your computer, add at least 1 GB of memory to your emulator. This is the value "Device ram size" during the creation of the AVD. Also set the flag "Enabled" for Snapshots. This will save the state of the emulator and let it start much faster.
converted by Web2PDFConvert.com
We can also select the box "Enabled" for Snapshots. This will make the second start of the virtual device much faster. At the end press the button "Create AVD". This will create the AVD configuration and display it under the "Virtual devices". To test if your setup is correct, select your device and press "Start". After (a long time) your AVD starts. You are able to use it via the mouse and via the virtual keyboard of the emulator.
7.3. LogCat
The "LogCat" View shows you the log messages of your Android device and help you analyze problems. For example Java exceptions in your program would be shown here. To open this view, select Window Show View Other Android LogCat.
converted by Web2PDFConvert.com
name.
converted by Web2PDFConvert.com
converted by Web2PDFConvert.com
While "res" contains structured values which are known to the Android platform the directory "assets" can be used to store any kind of data. In Java you can access this data via the AssetsManager and the method getAssets().
converted by Web2PDFConvert.com
Add also the following "String" attributes. String attributes allow the developer to translate the application at a later point.
Right-click on the text object Hello World, Hello! in the layout. Select Delete on the popup menu to remove the text object. Then, from the Palette view, select Text Fields and locate Plain Text. Drag this onto the layout to create a
converted by Web2PDFConvert.com
text input field. All object types in the section "Text Fields derive from the class "EditText", they just specify via an additional attribute which text type can be used. Now select the Palette section Form Widgets and drag a RadioGroup object onto the layout. The number of radio buttons added to the radio button group depends on your version of Eclipse. Make sure there are two radio buttons by deleting or adding radio buttons to the group. From the Palette section Form Widgets, drag a Button object onto the layout. The result should look like the following.
Switch to "main.xml" and verify that your XML looks like the following.
<?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"> <EditText android:layout_height="wrap_content" android:id="@+id/editText1" android:layout_width="match_parent" android:text="EditText"></EditText> <RadioGroup android:layout_height="wrap_content" android:id="@+id/radioGroup1" android:layout_width="match_parent"> <RadioButton android:text="RadioButton" android:layout_width="wrap_content" android:id="@+id/radio0" android:layout_height="wrap_content" android:checked="true"></RadioButton> <RadioButton android:text="RadioButton" android:layout_width="wrap_content" android:id="@+id/radio1" android:layout_height="wrap_content"></RadioButton> </RadioGroup> <Button android:text="Button" android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button> </LinearLayout>
converted by Web2PDFConvert.com
From now on I assume you are able to use the properties menu on the UI elements. You can either edit the XML file or modify the properties via right mouse click. Set the property "Checked" to true for the first RadioButton. Assign "calc" to the text property of your button and assign "myClickHandler" to the "onClick" property. Set the "Input type" property to "numberSigned" and "numberDecimal" on your EditText. All your other UI controls are contained in a LinearLayout. We want to assign a background color to this LinearLayout. Right-click on an empty space in Graphical Layout mode, then select Other Properties All by Name Background. Select Color and then myColor in the list.
Switch to the "main.xml" tab and verify that the XML is correctly maintained.
<?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" android:background="@color/myColor"> <EditText android:layout_height="wrap_content" android:id="@+id/editText1" android:layout_width="match_parent" android:inputType="numberDecimal|numberSigned"></EditText> <RadioGroup android:layout_height="wrap_content" android:id="@+id/radioGroup1" android:layout_width="match_parent"> <RadioButton android:layout_width="wrap_content" android:id="@+id/radio0" android:layout_height="wrap_content" android:text="@string/celsius" android:checked="true"></RadioButton>
converted by Web2PDFConvert.com
<RadioButton android:layout_width="wrap_content" android:id="@+id/radio1" android:layout_height="wrap_content" android:text="@string/fahrenheit"></RadioButton> </RadioGroup> <Button android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/calc" android:onClick="myClickHandler"></Button> </LinearLayout>
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); text = (EditText) findViewById(R.id.editText1);
}
// This method is called at button click because we assigned the name to the // "On Click property" of the button public void myClickHandler(View view) { switch (view.getId()) { case R.id.button1: RadioButton celsiusButton = (RadioButton) findViewById(R.id.radio0); RadioButton fahrenheitButton = (RadioButton) findViewById(R.id.radio1); if (text.getText().length() == 0) { Toast.makeText(this, "Please enter a valid number", Toast.LENGTH_LONG).show(); return; }
float inputValue = Float.parseFloat(text.getText().toString()); if (celsiusButton.isChecked()) { text.setText(String .valueOf(convertFahrenheitToCelsius(inputValue))); celsiusButton.setChecked(false); fahrenheitButton.setChecked(true); } else { text.setText(String .valueOf(convertCelsiusToFahrenheit(inputValue))); fahrenheitButton.setChecked(false); celsiusButton.setChecked(true); } break; } }
// Converts to celsius private float convertFahrenheitToCelsius(float fahrenheit) { return ((fahrenheit - 32) * 5 / 9); } // Converts to fahrenheit private float convertCelsiusToFahrenheit(float celsius) { return ((celsius * 9) / 5) + 32; } }
converted by Web2PDFConvert.com
Type in a number, select your conversion and press the button. The result should be displayed and the other option should get selected.
converted by Web2PDFConvert.com
In this method you can create the menu programmatically or you can use a pre-defined XML resources which you inflate via the class "MenuInflator". Each activity has already an instance of the class available and this instance can get accessed via the method getMenuInflator(). onCreateContextMenu() is only called once. If you want to influence the menu later you have to use the method onPrepareOptionsMenu().
11.1. Project
This chapter will demonstrate how to create and evaluate a option menu which is displayed in the action bar if sufficient space is available. This example will be extended in the chapter about preferences. Create a project "de.vogella.android.socialapp" with the activity "OverviewActivity". Change the UI in the file "/res/layout/main.xml" to the following:
<?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" > <Button android:id="@+id/Button01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Show Preferences" > </Button> <Button android:id="@+id/Button02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Change Preferences" > </Button> </LinearLayout>
This will create a new file "mainmenu.xml" in the folder "res/menu" of your project. Android provides a nice editor to edit this file, unfortunately this editor is not always automatically used due to bugs in the ADT. If that happens you can open this editor manually. Right-click on your menu file and select Open with Android Menu Editor. Switch if necessary to the "Layout" tab of the editor. Press Add and select "Item". Maintain the following value. This defines the entries in your menu. We will also define that the menu entry is displayed in the action bar if there is sufficient space available.
converted by Web2PDFConvert.com
Change your Activity class "OverviewActivity" to the following. The OnCreateOptionsMenu method is used to create the menu. The behavior in "onOptionsItemSelected" is currently hard-coded to show a Toast and will soon call the preference settings. In case you want to disable or hide menu items you can use the method "onPrepareOptionsMenu" which is called every time the menu is called.
package de.vogella.android.socialapp; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.widget.Toast; public class OverviewActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); }
@Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.mainmenu, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { Toast.makeText(this, "Just a test", Toast.LENGTH_SHORT).show(); return true; } }
Run your application. As there is enough space in the action bar your item will be displayed there. If there would be more items you could press "Menu" on the emulator to see them. If you select the menu item you should see a small info message.
converted by Web2PDFConvert.com
The two "Preference" buttons are not yet active. We will use them in the next chapter.
12. Preferences
Android supports the usage of Preferences to allow you to save data for your application. Preferences are stored as key values. The definition of Preferences can also be done via an XML resource. Android provides the class "PreferenceActivity" which extends the class Activity. PreferenceActivity supports the simple handling of preferences. This activity can load a preference definition resources via the method addPreferencesFromResource(). To communicate between different components Android uses Intents. Typically the PreferenceActivity is started from another activity via an Intent. In your application you can access the preference manager via the following:
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
Values can get access via the key of the preference setting.
String username = preferences.getString("username", "n/a");
To create or change preferences you have to call the edit() methods. Once you have changed the value you have to call commit() to apply your changes.
converted by Web2PDFConvert.com
Open the file via right-mouse click and Open-with Android XML Resource Editor. Press Add, add a "PreferenceCategory" and add two preferences "EditTextPreferences" to this category : "User" and "Password".
You can also enter values for other properties of EditTextField, e.g. the inputMethod. Add the following attribute to the XML definition of your password field to make the input quoted with *.
android:inputType="textPassword"
Create the class MyPreferencesActivity which extends PreferenceActivity. This Activity will load the "preference.xml" file and will allow the user to change the values.
package de.vogella.android.socialapp; import android.os.Bundle; import android.preference.PreferenceActivity; public class MyPreferencesActivity extends PreferenceActivity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); } }
To make this class available as an activity for Android you need to register it in your "AndroidManifest.xml" file. Select "AndroidManifest.xml" and the tab "Application". Scroll to the botton of the view and add your new activity via the "Add" button.
To make use of our new preference activity and the preference values we adjust the "OverviewActivity". The first button will show the current values of the preferences via a Toast and the second button will revert the maintained user name to demonstrate how you could change the preferences via code.
package de.vogella.android.socialapp; import android.app.Activity; import android.content.SharedPreferences; import android.content.SharedPreferences.Editor; import android.os.Bundle; import android.preference.PreferenceManager; import android.view.Menu;
converted by Web2PDFConvert.com
import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.Toast; public class OverviewActivity extends Activity { SharedPreferences preferences; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button button = (Button) findViewById(R.id.Button01); // Initialize preferences preferences = PreferenceManager.getDefaultSharedPreferences(this); button.setOnClickListener(new OnClickListener() { public void onClick(View v) { String username = preferences.getString("username", "n/a"); String password = preferences.getString("password", "n/a"); showPrefs(username, password); } }); Button buttonChangePreferences = (Button) findViewById(R.id.Button02); buttonChangePreferences.setOnClickListener(new OnClickListener() { public void onClick(View v) { updatePreferenceValue(); } }); } private void showPrefs(String username, String password){ Toast.makeText( OverviewActivity.this, "Input: " + username + " and password: " + password, Toast.LENGTH_LONG).show(); } private void updatePreferenceValue(){ Editor edit = preferences.edit(); String username = preferences.getString("username", "n/a"); // We will just revert the current user name and save again StringBuffer buffer = new StringBuffer(); for (int i = username.length() - 1; i >= 0; i--) { buffer.append(username.charAt(i)); } edit.putString("username", buffer.toString()); edit.commit(); // A toast is a view containing a quick little message for the // user. We give a little feedback Toast.makeText(OverviewActivity.this, "Reverted string sequence of user name.", Toast.LENGTH_LONG).show(); }
To open the new preference Activity we will use the onOptionsItemSelected() method. Even though we currently have only one option in our menu we use a switch to be ready for several new menu entries. To see the current values of the preferences we define a button and use the class PreferenceManager to get the sharedPreferences.
@Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.mainmenu, menu); return true; } // This method is called once the menu is selected @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { // We have only one menu option case R.id.preferences: // Launch Preference activity Intent i = new Intent(OverviewActivity.this, MyPreferencesActivity.class); startActivity(i); // Some feedback to the user Toast.makeText(OverviewActivity.this, "Enter your user credentials.", Toast.LENGTH_LONG).show(); break;
} return true; }
13.2. Run
Run your application. Press the "menu" hardware button and then select your menu item "Preferences". You should be able to enter your user settings then press the back hardware button to return to your main activity. The saved values should be displayed in a small message windows (Toast) if you press your first button. If you press the second button the username should be reversed.
converted by Web2PDFConvert.com
@Override protected Dialog onCreateDialog(int id) { switch (id) { case 10: // Create out AlterDialog Builder builder = new AlertDialog.Builder(this); builder.setMessage("This will end the activity"); builder.setCancelable(true); builder.setPositiveButton("I agree", new DialogInterface.OnClickListener() {
converted by Web2PDFConvert.com
public void onClick(DialogInterface dialog, int which) { ShowMyDialog.this.finish(); } }); builder.setNegativeButton("No, no", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { Toast.makeText(getApplicationContext(),"Activity will continue",Toast.LENGTH_LONG).show(); } }); AlertDialog dialog = builder.create(); dialog.show(); } return super.onCreateDialog(id); } }
If you run your application and click your button you should see your dialog.
15.2. LinearLayout
LinearLayout puts all its child elements into a single column or row depending on the android:orientation attribute. Possible values for this attribute are horizontal and vertical, horizontal is the default value. LinearLayout can be nested to achieve more complex layouts.
15.3. GridLayout
15.3.1. Overview
GridLayout was introduced with Android 4.0. This layout allows you to organize a view into a Grid. GridLayout separates its drawing area into: rows, columns, and cells. You can specify how many columns you want for define for each View in which row and column it should be placed and how many columns and rows it should use. It not specified GridLayout uses default, e.g. on column, one row and position depending on the order of the declaration of the views.
Create the project "de.vogella.android.layout.gridlayout" with the Activity called "DemoGridLayout". Change "main.xml" to the following.
<?xml version="1.0" encoding="utf-8"?> <GridLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/GridLayout1" android:layout_width="fill_parent" android:layout_height="fill_parent" android:columnCount="4" android:useDefaultMargins="true" > <TextView android:layout_column="0" android:layout_columnSpan="3" android:layout_gravity="center_horizontal" android:layout_marginTop="40dp" android:layout_row="0" android:text="User Credentials" android:textSize="32dip" /> <TextView android:layout_column="0" android:layout_gravity="right" android:layout_row="1" android:text="User Name: " > </TextView> <EditText android:id="@+id/input1" android:layout_column="1" android:layout_columnSpan="2" android:layout_row="1" android:ems="10" /> <TextView android:layout_column="0" android:layout_gravity="right" android:layout_row="2" android:text="Password: " > </TextView> <EditText android:id="@+id/input1" android:layout_column="1" android:layout_columnSpan="2" android:layout_row="2" android:ems="8" /> <Button android:id="@+id/button1" android:layout_column="2" android:layout_row="3" android:text="Login" /> </GridLayout>
Run your example. You should see a nice arranged layout. This is a layout example wherefore we have not connected any functionality to it. To extend this example you could now connect the Button with a method in the Activity via its android:onClick.
16. ScrollView
ScrollViews can be used to contain one view that might be to big to fit on one screen. If the view is to big the ScrollView will display a scroll bar to scroll the context. Of course this view can be a layout which can then contain other elements. Create an android project "de.vogella.android.scrollview" with the activity "ScrollView". Create the following layout and class.
<?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:fillViewport="true" android:orientation="vertical" > <LinearLayout android:id="@+id/LinearLayout01" android:layout_width="fill_parent" android:layout_height="wrap_content" android:orientation="vertical" > <TextView android:id="@+id/TextView01" android:layout_width="wrap_content"
converted by Web2PDFConvert.com
android:layout_height="wrap_content" android:paddingLeft="8dip" android:paddingRight="8dip" android:paddingTop="8dip" android:text="This is a header" android:textAppearance="?android:attr/textAppearanceLarge" > </TextView> <TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="fill_parent" android:layout_weight="1.0" android:text="@+id/TextView02" > </TextView> <LinearLayout android:id="@+id/LinearLayout02" android:layout_width="wrap_content" android:layout_height="wrap_content" > <Button android:id="@+id/Button01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1.0" android:text="Submit" > </Button> <Button android:id="@+id/Button02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1.0" android:text="Cancel" > </Button> </LinearLayout> </LinearLayout> </ScrollView>
package de.vogella.android.scrollview; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.TextView; public class ScrollView extends Activity { /** Called when the activity is first created. */
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); TextView view = (TextView) findViewById(R.id.TextView02); String s=""; for (int i=0; i < 100; i++) { s += "vogella.de "; } view.setText(s); }
}
The attribute "android:fillViewport="true"" ensures that the scrollview is set to the full screen even if the elements are smaller then one screen and the "layout_weight" tell the android system that these elements should be extended.
converted by Web2PDFConvert.com
17. Fragments
17.1. Overview
Fragment components allow you to organize your application code so that it is easier to support different sized devices. Fragments are components with their own lifecycle and their own user interface. They can be defined via layout files or via coding. Fragments always run in the context of an Activity. If an Activity is stopped its Fragments will also be stopped; if an Activity is destroyed its Fragments will also get destroyed. If a Fragment component is defined in an XML layout file, the android:name attribute points to the Fragments class. The base class for Fragments is android.app.Fragment. For special purposes you can also use more special classes, like ListFragment or DialogFragment. The onCreateView() method is called by Android once the Fragment should create its user interface. Here you can inflate an layout. The onStart() method is called once the Fragment gets visible. Fragments can be dynamically added and removed from an Activity via Fragment transactions. This will add the action to the history stack of the Activity, i.e. this will allow to revert the Fragment changes in the Activity via the back button.
To create different layouts with Fragments you can: Use one activity, which displays two Fragments for tablets and only one on handsets devices. In this case you would switch the Fragments in the activity whenever necessary. This requires that the fragment is not declared in the layout file as such Fragments cannot be removed during runtime. It also requires an update of the action bar if the action bar status depends on the fragment. Use separate activities to host each fragment on a handset. For example, when the tablet UI uses two Fragments in an activity, use the same activity for handsets, but supply an alternative layout that includes just one fragment. When you need to switch Fragments, start another activity that hosts the other fragment. The second approach is the most flexible and in general preferable way of using Fragments. In this case the main activity checks if the detail fragment is available in the layout. If the detailed fragment is there, the main activity tells the fragment that is should update itself. If the detail fragment is not available the main activity starts the detailed activity. It is good practice that Fragments do not manipulate each other. For this purpose a Fragment typically implements an interface to get new data from its host Activity.
The following tutorial demonstrates how to use Fragments. The entry Activity (called MainActivity of our application ) will use different layouts for portrait and for landscape mode. In portrait mode MainActivity will show one Fragment with a list of names. If the user touches an item in the list, a second Activity called DetailActivity will start and show the selected text. In landscape mode MainActivity will show two Fragments. The first is again the Fragments which shows the list of names. The second Fragment shows the text of the current selected item. This is similar to the portrait mode, but the whole information will be shown on one screen.
Change the existing "main.xml" file. This layout will be used by MainActivity in landscape mode and shows two Fragments.
<?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="horizontal" > <fragment android:id="@+id/listFragment" android:layout_width="150dip" android:layout_height="match_parent" android:layout_marginTop="?android:attr/actionBarSize" class="de.vogella.android.fragments.ListFragment" ></fragment> <fragment android:id="@+id/detailFragment" android:layout_width="match_parent" android:layout_height="match_parent" class="de.vogella.android.fragments.DetailFragment" > <!-- Preview: layout=@layout/details --> </fragment> </LinearLayout>
@Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); String[] values = new String[] { "Android", "iPhone", "WindowsMobile", "Blackberry", "WebOS", "Ubuntu", "Windows7", "Max OS X",
converted by Web2PDFConvert.com
@Override public void onListItemClick(ListView l, View v, int position, long id) { String item = (String) getListAdapter().getItem(position); DetailFragment fragment = (DetailFragment) getFragmentManager() .findFragmentById(R.id.detailFragment); if (fragment != null && fragment.isInLayout()) { fragment.setText(item); } else { Intent intent = new Intent(getActivity().getApplicationContext(), DetailActivity.class); intent.putExtra("value", item); startActivity(intent);
} } }
@Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.inflate(R.layout.details, container, false); return view; }
public void setText(String item) { TextView view = (TextView) getView().findViewById(R.id.detailsText); view.setText(item); } }
Also create the "details_activity_layout.xml" layout file. This layout will be used in the DetailActivity which is only used in portrait mode. Please note that we could have create this file also in the "layout" folder, but as it is only used in portrait mode it is best practise to place it into this folder.
converted by Web2PDFConvert.com
<?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" android:orientation="vertical" > <fragment android:id="@+id/detailFragment" android:layout_width="match_parent" android:layout_height="match_parent" class="de.vogella.android.fragments.DetailFragment" /> </LinearLayout>
18.6. Activities
Create a new Activity called DetailActivity with the following class.
package de.vogella.android.fragments; import android.app.Activity; import android.os.Bundle; import android.widget.TextView; public class DetailActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.details_activity_layout); Bundle extras = getIntent().getExtras(); if (extras != null) { String s = extras.getString("value"); TextView view = (TextView) findViewById(R.id.detailsText); view.setText(s); } } }
18.7. Run
Run your example. If you run the application in portrait mode you should see only one Fragment. Use Ctrl+F11 to switch the orientation. In horizontal mode you should see two Fragments. If you select an item in portrait mode a new Activity should get started with the selected item. In horizontal mode your second Fragment should display the select item.
converted by Web2PDFConvert.com
20. Shell
20.1. Android Debugging Bridge - Shell
You can access your Android emulator also via the console. Open a shell, switch to your "android-sdk" installation directory into the folder "tools". Start the shell via the following command "adb shell".
adb shell
You can also copy a file from and to your device via the following commands.
// Assume the gesture file exists on your Android device adb pull /sdcard/gestures ~/test // Now copy it back adb push ~/test/gesture /sdcard/gestures2
This will connect you to your device and give you Linux command line access to the underlying file system, e.g. ls, rm, mkdir, etc. The application data is stored in the directory "/data/data/package_of_your_app". If you have several devices running you can issue commands to one individual device.
# Lists all devices adb devices #Result List of devices attached emulator-5554 attached emulator-5555 attached # Issue a command to a specific device adb -s emulator-5554 shell
converted by Web2PDFConvert.com
For more information on the emulator console please see Emulator Console manual
converted by Web2PDFConvert.com
converted by Web2PDFConvert.com