- Android Programming for Beginners
- Table of Contents
- Android Programming for Beginners
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Preface
- 1. The First App
- 2. Java – First Contact
- 3. Exploring Android Studio
- 4. Designing Layouts
- 5. Real-World Layouts
- 6. The Life and Times of an Android App
- 7. Coding in Java Part 1 – Variables, Decisions, and Loops
- 8. Coding in Java Part 2 – Methods
- 9. Object-Oriented Programming
- Important memory management warning
- Introducing OOP
- Taking a look at the code for a class
- The basic classes mini app
- Remember that encapsulation thing?
- Encapsulation and static methods mini app
- OOP and inheritance
- The inheritance mini app
- Polymorphism
- FAQ
- Summary
- 10. Everything's a Class
- 11. Widget Mania
- 12. Having a Dialogue with the User
- 13. Handling and Displaying Arrays of Data
- 14. Handling and Displaying Notes in Note To Self
- 15. Android Intent and Persistence
- 16. UI Animations
- 17. Sound FX and Supporting Different Versions of Android
- 18. Design Patterns, Fragments, and the Real World
- Introducing the model-view-controller pattern
- The imperfections of Note To Self revisited
- Android design guidelines
- Real-world apps
- The device detection mini app
- Configuration qualifiers
- Using configuration qualifiers – mini app
- Fragments
- Our first working Fragment mini app
- Fragment reality check
- FAQ
- Summary
- 19. Using Multiple Fragments
- Using singletons for the model layer
- Inter-Fragment communications – interfaces revisited
- The dual-Fragment address book mini app
- Getting started
- Alias resources
- The NameAndAddress class
- Creating the communication interface
- Explaining the structure of the onListItemSelected method
- Explaining the code that starts a new Activity
- Explaining the code when the detail Fragment is already present
- What do we need to do?
- Creating the AddressDetailFragment class and layout
- Coding PortraitDetailActivity and the layout
- FAQ
- Summary
- 20. Paging and Swiping
- 21. Navigation Drawer and Where It's Snap
- 22. Capturing Images
- 23. Using SQLite Databases in Our Apps
- 24. Adding a Database to Where It's Snap
- 25. Integrating Google Maps and GPS Locations
- 26. Upgrading SQLite – Adding Locations and Maps
- 27. Going Local – Hola!
- 28. Threads, Touches, Drawing, and a Simple Game
- 29. Publishing Apps
- 30. Before You Go
- Index
Create a new project and call it Configuration Qualifiers and follow the next steps:
- Right-click on the
resfolder in the project explorer and navigate to New | Android resource directory. Typelayout-landand click on OK. - In the
layout_main.xmlfile, change the text of the default TextView widget fromHello worldtoHello portrait!. - Right-click on the
layout-landfolder and navigate to New | Layout resource. Name the filelayout_main.xml. Add a single Plain TextView widget and change thetextproperty toHello landscape!. - Run the app and rotate the device between landscape and portrait orientations. Note that the OS automatically uses the appropriate version of
layout_main.xml.
If we got a reference to TextView (or any other widget) in our Java code, the same exact code would work as long as the id values in the different layouts were the same.
Effectively, we have two different layouts controlled by the same Java code.
What the last two mini apps and our discussion on configuration qualifiers have shown us is certainly very useful in a number of situations. Unfortunately, however, configuration qualifiers and detecting attributes in code only solve the problem in the view layer of our MVC pattern. As discussed in the Real-world apps section, our apps sometimes need to have a different behavior as well as layout. This perhaps implies multiple branches of our code in the controller layer and perhaps summons nightmarish visions of having huge great if or switch blocks with different code for each different scenario.
Fortunately, this is not how it's done. For such situations (actually for most apps), Android has Fragments.
-
No Comment