Android Jump Start
0 likes1,538 views
This document provides an overview of building Android applications. It discusses Android application components like activities, broadcast receivers, services, and content providers. It also covers the application manifest, resources and UI, and the Android SDK. The document gives examples of creating a simple first app with one activity, adding a menu, and incorporating a tab host with internal browser functionality. It discusses signing your application in preparation for publishing.
Android Jump Start
- 1. Android Jump Start ConFoo Mar 11, 2011 Mike Willbanks Blog: http://blog.digitalstruct.com Twitter: mwillbanks IRC: lubs on freenode
- 2. Outline ● Overview ● Building an App ● What is Android ● A First App ● Application Components ● And many other things ● Application Manifest ● Resources and UI ● The SDK
- 3. What is Android? “Android is a software stack for mobile devices that includes an operating system, middleware and key applications.”
- 4. Application Components
- 5. Application Components ● Activities ● Representative of a single screen UI*. ● Broadcast Receivers ● A component that responds to systemwide broadcast announcements. ● Services ● A component running in the background handling long running operations and/or performing work for remote processes. ● Content Providers ● A component that manages a shared set of application data.
- 6. Activities ● Provides a screen where users can interact to do “something” ● Generally correspond to a single screen in a UI ● Exceptions: Faceless or Floating Windows ● Think of it as a Controller in MVC ● However, it does include much of the View.
- 9. Intents ● Events / Messages ● The Application Glue ● Intents can be thought of as a hyperlink in a web application. ● Launching new activities requires an Intent. ● Intents also describe what is to be done. ● Such as playing a video, making a call, etc. ● A good list can be found at http://openintents.org/ ● IntentFilters determine which Activities can be serviced via AndroidManifest.xml
- 10. Broadcast Receivers ● Components that respond to Broadcast Intents ● Examples include C2dm, Low Battery, Screen Turned Off/On, Change in Timezone, Wifi Turned Off/On, etc. ● Essentially an external event or an alarm ● You can also create and initiate your own Broadcast Intents ● Intended to do a minimal amount of work ● Longer running processes should either launch or utilize a Service component.
- 11. Services ● Components that run in the background ● No UI (faceless) ● Poll requests, Downloads, MP3 Playback ● Bound and Unbound ● Bound services are managed by an Activity ● Unbound services are expected to manage themselves. ● Runs in the main thread, unless otherwise specified ● In the event of CPU intensive or blocking operations create a new thread.
- 13. Content Providers ● The only way to share data between applications. ● You must ask for permission to these assets. ● Access to several types of data ● Alarm Clock, Browser, Contacts, Media (Music, Video, Images), System Level Settings, User Dictionary ● Each application can utilize exiting and define their own. ● Generally utilized through SQLite
- 14. Application Manifest
- 15. Application Manifest ● Every application MUST have an ApplicationManifest.xml file. ● It tells Android about your application ● The package name ● Application components (Activities / Services / Broadcast Receivers / Content Providers) ● Permissions required / requested ● Minimum and Target SDK versions ● Linked Libraries
- 17. Application Manifest: Legal Elements ● action ● permissiongroup ● activity ● permissiontree ● activityalias ● provider ● application ● receiver ● category ● service ● data ● supportsscreens ● granturipermission ● usesconfiguration ● instrumentation ● usesfeature ● intentfilter ● useslibrary ● manifest ● usespermission ● metadata ● usessdk ● permission
- 18. Resources and UI
- 19. Resources ● Resources are contained in the /res folder ● Resource Types: – anim: Tween Animations – color: State List of Colors – drawable: Bitmaps aka Images – layout: UI on Screen – menu: Options Menu / Context Menu / Sub Menu – raw: Files you'd open with Input Stream – values: Arrays, Colors, Dimensions, Strings, Styles – xml: configuration / searchable configuration
- 20. Resources: The Qualifiers ● Basic resources are stored at the root folders ● Resources have qualifiers that allow you to customize the experience which separate the folders by a dash. ● Localization (Country / Region / Language) ● Screen (Size / Touch / Orientation / Ratio / Density) ● Navigation (State / Method) ● Dock or Night mode ● API Version ● Generally, you'll keep it simple but have adjustments for: Orientation, Size and Language.
- 21. Resources: An example layout ● Items in red are generic resources. ● Blue items are qualitative and if not matched fall back to generic.
- 22. Resources: Strings ● The string XML file defines a name (key) for your text ● Stylization is possible with some HTML elements – Bold, Italic, Underline, Monospace, Superscript, Subscript and Strikethrough (b, i, u, tt, big, small, sup, sub, strike)
- 23. Resources: Layouts ● The Layout is the screen view of your application. ● There are several types of layouts: ● FrameLayout: The simplest layout ● LinearLayout: Aligns children in a single direction ● TableLayout: Most frustrating layout ● RelativeLayout: The most common layout ● There are several other specialty views available to wrap the layouts ● ScrollView, TabHost, ViewFlipper, GridView, etc.
- 24. Resources: Layouts: Elements ● Contained in each layout is generally XML defining each type of element of widget you want to use. ● From a high level view these include – Button, Checkbox, DatePicker, EditText, ImageView, ListView, TextView ● You can find all of these in the android.widget package.
- 26. SDK
- 27. SDK: Overview ● The SDK contains everything you need to build an android application, however, to aide you they also made an eclipse plugin ADT. ● After installing the SDK, I recommend you install the eclipse plugin – it will save you time later. ● Launch the SDK and install all available packages ● This is useful for testing the emulator with different versions as well as ensuring you have the Google API's as well. ● Windows users: You need to ensure you download the USB driver if you plan to use your phone for testing.
- 29. Building An App
- 30. Our First Activity: Building the Project ● Before we begin anything we need to start an android project. I prefer ant, so creating this project is quick:
- 31. Our First Activity: Installing the Project ● We now have an application, that is installable. ● If our emulator is running – we can just run: – ant install ● Note: If you are using an actual device and you are on linux, you must start the “adb” server as root: sudo adb startserver
- 32. Our First Activity: Changing the Theme and Icon ● I am not a fan of the black background and how the interface looks, luckily android supports themes! ● Canned Themes can be found in the sdk folder: platforms/androidver/data/res/values/themes.xml – We'll use Theme.Light ● Themes can be applied to a whole application, an activity or an element. – We will change it on the whole application, which simply requires a change to the AndroidManifest.xml file. ● Want to make your own theme? – Extend one of the ones already made.
- 34. Our First Activity: Adding a Logo ● Let's take a confoo logo and put it at the top of the activity. ● Since there is no generic “drawable” resource we'll make one and store it there. ● We can then reference the image in our xml as @drawable/confoo ● The activity's layout is current set as “main.xml” in res/layout
- 36. Our First Activity: Updating the Text ● So the canned text is currently hard coded and not using the res/values/strings.xml file. Let's change that and update it. While we are there we will update the application name. ● Referencing strings in our application is as easy as @string/name we'll make this change in our layout after we add the keys.
- 38. Adding A Menu
- 39. Adding a Menu: Using res/menu ● To build a menu, we simply need to add an xml file to res/menu and incorporate it into our code. ● Using the stock icons you can find under the androidsdkdir/platforms/androidver/res/drawable * ● We also need to add in code to our activity to make this menu load. ● We will add in a menu item for the Schedule, Joind.in and Twitter.
- 42. Adding a Menu: Incorporate WebKit ● To make this menu functional let's introduce a browser. ● Here we can use Intents to launch a specific URL in the browser.
- 43. Adding A TabHost
- 44. Adding a TabHost ● A TabHost allows us to have several open actions at once and keep the state of them during that time. ● It also lets us navigate the app slightly easier. ● Let's put the same things that we have in the menu bar there for now. – But, we need to modify this as well. Let's use webkit in our own internal browser. ● This also means we now need to create a tabhost activity and change the manifest to go to the tab host activity first.
- 47. The Tab Host
- 48. The Tab Host
- 50. Publishing
- 51. Signing your Application ● First step in publishing is generating a private key: keytool -genkey -v -keystore my-release-key.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000 ● Secondly, if you are using ant and want to automate release builds modify local.properties with your passphrase: ● Now, let it rip: ant release ● Now it is off to market.android.com/publish
- 52. Advanced Stuff
- 53. Gotchas ● When using an AsyncTask ● Always ensure you check you're still in the view you need. Crashing issues apply. ● When using a Progress Dialog ● Ensure it still exists and that it is showing – never assume it is still existing. ● Some code to give you a better idea:
- 55. Gotchas ● If your configuration changes (Orientation Change), ensure that you stated it in your AndroidManifest as well as your Activity to handle things such as Progress Dialogs ● Android by default will recreate the view and activity.
- 56. Gotchas
- 57. Gotchas ● If your server utilizes tokens or some form of sessions ● When you close the application, it will remain in a background process until android needs memory. Ensure that you handle this – users become unhappy otherwise :) ● Before you use the internet make sure that it does exist :)
- 58. C2dm ● Cloud 2 Device Messaging works basically the same as Apple Push Notification Service, except far more flexible. ● Your application registers a broadcast receiver and fires off an intent to register the device. You receive back an ID that you subsequently store on your own server. ● We're talking about how to handle this in your app – the web server part is far more complex: ● See: http://blog.digitalstruct.com/2010/11/21/android c2dmwithphpandzendframework/
- 59. C2dm ● What needs to happen ● Ask for permissions in the manifest, publish a broadcast receiver and ask google for the registration ID ● Before that although, you do need to sign up: http://code.google.com/android/c2dm/index.html
- 63. Questions? Mike Willbanks Blog : http://blog.digitalstruct.com Twitter : mwillbanks IRC : lubs on freenode