Xamarin Blueprints

Table of contents

1. Xamarin Blueprints
   1. Xamarin Blueprints
   2. Credits
   3. About the Author
   4. About the Reviewer
   5. www.PacktPub.com
      1. Why subscribe?
   6. Preface
      1. What this book covers
      2. What you need for this book
      3. Who this book is for
      4. Conventions
      5. Reader feedback
      6. Customer support
         1. Downloading the example code
         2. Errata
         3. Piracy
         4. Questions
   7. 1. Building a Gallery Application
      1. Create an iOS project
      2. Creating a UIViewController and UITableView
      3. Customizing a cell's appearance
      4. Creating an Android project
      5. Creating an XML interface and ListView
      6. Shared projects
      7. Custom row appearance
      8. Bitmap functions
      9. The ALAssetLibrary
      10. Adding the iOS photo screen
      11. Adding the Android photo screen
      12. Summary
   8. 2. Building a SpeechTalk Application
      1. Cross-platform development with Xamarin.Forms
         1. So how would this look in Xamarin.Forms?
      2. Setting up platform projects
         1. So what is happening here?
      3. Setting up the SpeechTalk.iOS project
      4. Setting up the SpeechTalk.Droid project
      5. Xamarin.Forms, Windows Phone, and Visual Studio
         1. What can we see here?
      6. Inversion of Control (IoC) with Xamarin.Forms
         1. So why should we use it?
         2. So how do we benefit from this?
      7. Autofac
      8. iOS text-to-speech implementation
      9. Bindings
      10. Android text-to-speech implementation
      11. Setting up IoC with Android
      12. WinPhone text-to-speech implementation
      13. IoC with Windows Phone
      14. Platform independent styling
      15. Summary
   9. 3. Building a GPS Locator Application
      1. Core location and GPS
         1. Project setup
         2. Navigation with Xamarin.Forms
         3. Why would we do this?
         4. Building the navigation control
         5. View model navigation
         6. Integrating Google Maps using Xamarin.Forms.Maps
         7. Reactive Extensions
         8. Core location with iOS and the CLLocationManager library
      2. Handling location updates
         1. Android and the LocationManager
         2. Creating an exit point
         3. Creating an API key for Android
         4. Creating our Windows project
         5. Core Location Services with Windows Phone
         6. The Application class
         7. Web services and data contracts
         8. What about data contracts?
         9. Creating another API key for geocoding
         10. Creating GeocodingWebServiceController
         11. Newtonsoft.Json and Microsoft HTTP client libraries
         12. ModernHttpClient and client message handlers
         13. Feeding JSON data into the IObservable framework
         14. More Reactive Extensions
         15. Resource (RESX) files
         16. Using GeocodingWebServiceController
         17. OnNavigatedTo and OnShow
         18. Pythagoras equirectangular projection
         19. How are we going to calculate the closest position?
      3. Summary
   10. 4. Building an Audio Player Application
       1. Solution setup
       2. Inversion of control with MVVMCross
       3. View-models with Xamarin native
       4. Creating the bindings
       5. NSLayoutContraints
       6. MVVMCross setup inside the PCL
       7. Setting up MVVMCross with iOS
       8. Setting up MVVMCross with Android
       9. The SoundHandler interface
       10. Implementing the iOS SoundHandler using the AVAudioPlayer framework
       11. The Mvx IoC container
       12. The audio player
       13. A cleaner code approach to NSLayout
       14. Creating AudioPlayerPageViewModel
       15. Implementing the Android SoundHandler using the MediaPlayer framework
       16. XML and Mvx bindings
       17. MvxActivities
       18. Summary
   11. 5. Building a Stocklist Application
       1. Understanding the backend
       2. Creating an ASP.Net Web API 2 project
       3. Building an API controller
       4. Setting up the mobile projects
       5. Building core mobile projects
       6. Improving app performance
       7. Creating a global App.xaml
       8. Theming with ControlTemplates
       9. Updating the MainPageViewModel
       10. Creating the Stocklist web service controller
       11. ListViews and ObservableCollections
       12. Value converters
       13. Adding a DataTemplate to the global resource dictionary
       14. Styles
       15. Further optimization with XAML
       16. Creating StockItemDetailsPage
       17. Custom renderers
       18. Adding styles for custom elements
       19. Creating StockItemDetailsPageViewModel
       20. Setting up the native platform projects
       21. Hosting the Web API project locally
       22. Summary
   12. 6. Building a Chat Application
       1. The Model-View-Presenter (MVP) pattern
          1. So why bother with this approach?
       2. Architecture
          1. How do we determine which layers our project needs?
       3. SignalR
       4. Starting with Open Web Interface for .NET (OWIN)
          1. Creating an authorization server using OWIN OAuth 2.0
          2. OAuthAuthorizationServerProvider
          3. Use OAuthBearerAuthentication
       5. Setting up the AuthenticationRepository
          1. Configuring the Web API
          2. Building the AccountController
          3. Configuring OAuth Authentication with our Web API
          4. Building the SignalR Hub
       6. Setting up mobile projects
          1. Creating the SignalRClient
          2. Building the WebApiAccess layer
          3. Application state
       7. Setting up the navigation service
          1. Building the iOS navigation service
          2. Building the Android navigation service
          3. Building the iOS interface
       8. Handling Hub proxy callbacks
       9. Implementing the LoginPresenter
       10. Creating the connection between Presenter and View
       11. Building the LoginActivity
       12. Implementing the ClientsListPresenter
       13. Creating ClientListViewController
       14. The TaskCompletionSource framework
       15. Creating the ClientsListActivity
       16. Overriding the OnBackPressed activity
       17. Building the ListAdapter
       18. Building the ChatPresenter
       19. Building the iOS ChatView
       20. Extending the UIColor framework
       21. Android TableLayouts
       22. Building the Android ChatActivity
       23. Running the server and clients
       24. Summary
   13. 7. Building a File Storage Application
       1. Project structure setup
       2. Building a data access layer using SQLite
       3. Building the ISQLiteStorage interface
       4. Adding additional threading techniques
          1. How do we solve this problem?
       5. Creating the AsyncSemaphore
       6. Creating the AsyncLock
       7. Implementing native setup requirements for SQLite
       8. Implementing the IoC container and modules
       9. Implementing cross-platform logging
       10. Implementing the SQLiteStorage class
       11. Introduction to C# 6.0 syntax
       12. Handling alerts in view-models
       13. Building the IMethods interface
       14. Building the ExtendedContentPage
           1. Why are we implementing two different techniques for showing alerts?
       15. Building a CarouselView using custom layouts
       16. Adding scroll control to the CarouselView
       17. Building a CustomRenderer for native gestures
       18. Building the user interface
       19. Using a SynchronizationContext
           1. How do we know this context is from the main UI thread?
       20. Building the EditFilePage
       21. Behaviours
       22. Challenge
       23. Building the Windows Phone version
       24. Summary
   14. 8. Building a Camera Application
       1. Solution setup
       2. Building the MainPageViewModel class
       3. Improving the INotifiedPropertyChanged implementation
       4. Creating the custom UI objects
       5. Building the FocusView
       6. Xamarin.Forms animations
       7. Xamarin.Forms compound animations
       8. Building the CameraView
       9. Building a control for the iOS camera
       10. Building the iOS CameraRenderer
       11. Integrating the Android Camera2 framework
       12. Building the CameraViewRenderer in Android
       13. Handling native touch events through the FocusView
       14. Using RX to handle events
       15. Building a VisualElementRenderer for iOS
       16. Building the CustomImageRenderers
       17. Building the UIImageEffects class
       18. Building the CustomImageRenderer for Android
       19. Triggers
           1. Easing.SinIn
           2. Easing.SinOut
       20. Platform effects
       21. Building the CameraPage
       22. Adding native orientation events
       23. Challenge
       24. Summary