Your SlideShare is downloading. ×
Android Jump Start
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.


Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Android Jump Start


Published on

Published in: Technology

  • Be the first to comment

  • Be the first to like this

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. Android Jump Start ConFoo Mar 11, 2011 Mike Willbanks    Blog: 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 system­wide 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.    
  • 7. Activities: Tasks and Back Stack    
  • 8. Activities: The Lifecycle    
  • 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 ● 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.    
  • 12. Services: The Lifecycle    
  • 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    
  • 16. Application Manifest: An Example    
  • 17. Application Manifest: Legal Elements ● action ● permission­group ● activity ● permission­tree ● activity­alias ● provider ● application ● receiver ● category ● service ● data ● supports­screens ● grant­uri­permission ● uses­configuration ● instrumentation ● uses­feature ● intent­filter ● uses­library ● manifest ● uses­permission ● meta­data ● uses­sdk     ● 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 youd open with Input Stream – values: Arrays, Colors, Dimensions, Strings,  Styles – xml: configuration / search­able 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, youll 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.    
  • 25. Resources: Layouts: Example    
  • 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  APIs as well. ● Windows users: You need to ensure you download the  USB driver if you plan to use your phone for testing.    
  • 28. SDK: Navigating the SDK    
  • 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 start­server    
  • 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/android­ver/data/res/values/themes.xml – Well 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.  
  • 33. Our First Activity: Changing the Theme    
  • 34. Our First Activity: Adding a Logo ● Lets take a confoo logo and put it at the top of the  activity. ● Since there is no generic “drawable” resource well  make one and store it there. ● We can then reference the image in our xml as  @drawable/confoo ● The activitys layout is current set as “main.xml” in  res/layout    
  • 35. Our First Activity: Adding a Logo    
  • 36. Our First Activity: Updating the Text ● So the canned text is currently hard coded and not  using the res/values/strings.xml file.  Lets 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 well make this change in our layout  after we add the keys.    
  • 37. Our First Activity: Updating the Text    
  • 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  android­sdk­dir/platforms/android­ver/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, and Twitter.    
  • 40. Adding a Menu: res/menu/main.xml    
  • 41. Adding a Menu: The Activity    
  • 42. Adding a Menu: Incorporate WebKit ● To make this menu functional lets 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. ● Lets put the same things that we have in the menu  bar there for now. – But, we need to modify this as well.  Lets 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.    
  • 45. Making a Browser Activity    
  • 46. Making a Browser Activity    
  • 47. The Tab Host    
  • 48. The Tab Host    
  • 49. Changes to the Manifest    
  • 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 with your  passphrase: ● Now, let it rip: ant release   ● Now it is off to  
  • 52. Advanced Stuff   
  • 53. Gotchas ● When using an AsyncTask ● Always ensure you check youre 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:    
  • 54. Gotchas: AsyncTask + Progress Dialog    
  • 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 re­create 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. ● Were talking about how to handle this in your app –  the web server part is far more complex: ● See:­ c2dm­with­php­and­zend­framework/    
  • 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:    
  • 60. C2dm: The Manifest    
  • 61. C2dm: The Receiver    
  • 62. More Examples....    
  • 63. Questions? Mike Willbanks Blog : Twitter : mwillbanks IRC : lubs on freenode