Gone Mobile-logo

Gone Mobile

Technology Podcasts

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

Location:

United States

Description:

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

Language:

English


Episodes

98: MAUI Blazor Hybrid Apps

3/15/2024
In this conversation, Jon and Allan discuss Blazor hybrid development, specifically in the context of Maui. They explore the benefits and challenges of using Blazor in a hybrid setting, including performance considerations and compatibility with different platforms. They also discuss the use of Blazor web views in Maui apps and the integration of native APIs. The conversation highlights the flexibility and potential of Blazor hybrid for building mobile apps. In this conversation, Allan Ritchie and Jon discuss the challenges of cross-platform development and the differences between Web Assembly and Maui. They also explore the use of view models in Blazor and Maui, as well as the benefits of Maui for businesses. The conversation concludes with a discussion on the slow progress of web standards and the plugin packages of the week: MudBlazor and Radzen. Takeaways Blazor hybrid development allows for the integration of Blazor web views in Maui apps, providing the flexibility to leverage web technologies in a native app environment. Blazor's Razor syntax and evolving language features make it a powerful tool for building UI components, especially for forms and complex layouts. Blazor hybrid development can offer a faster development loop and improved productivity, especially when working on UI components that are shared between web and mobile platforms. The performance of Blazor web views in Maui apps can vary depending on the platform and the debugging environment, but overall, it can provide a reasonably good user experience. Maui hybrid apps provide a way to run code in both Web Assembly and Maui, allowing for cross-platform development. View models in Blazor and Maui can be used to organize code and share functionality between different platforms. Maui offers performance advantages and a native look and feel compared to web-based solutions. Maui provides an escape route for rendering technology and opens up new hiring markets for businesses. The slow progress of web standards can hinder the development of web apps compared to native solutions. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Small Talk 00:35 Introduction to Blazor Hybrid 01:23 Blazor Rendering Modes 02:15 Experience with Blazor Hybrid 04:21 Using Razor in Blazor 05:19 Mobile Blazor Bindings for Xamarin and Maui 06:18 Choosing Between Blazor and XAML 07:36 Using Blazor for Complex Layouts 08:39 Blazor Web Views in Maui 09:38 Benefits of Blazor Hybrid for Forms 10:22 Mixing Blazor and Native Components 11:38 Using Third-Party Control Libraries in Blazor 12:37 Improvements in Web View Performance 13:48 Comparing App Performance on Different Platforms 14:38 Preloading Blazor Content in Maui 15:12 Loading Experience in Blazor Hybrid 16:09 Debugging and Performance in Blazor Hybrid 19:57 Injecting Maui Services into Blazor Pages 21:05 Debugging Experience in Windows 22:25 Separating Blazor and Maui Projects 23:21 Using WebAssembly for Blazor 24:18 Benefits of Blazor Hybrid for Development 26:11 Choosing Between Blazor and Native App 27:28 Challenges of Cross-Platform Development 29:13 Understanding Maui Hybrid Apps 30:02 Differences Between Web Assembly and Maui 31:21 Performance and Native Look 33:08 View Models in Blazor 35:23 Using View Models in Maui 36:44 Navigation in Maui and Blazor 38:18 Naming Confusion: Maui Blazor Hybrid 39:25 Benefits of Maui for Businesses 43:29 Transitioning from Web App to Native App 45:20 The Slow Progress of Web Standards 49:45 Plugin Packages of the Week: MudBlazor and Radzen

Duration:00:52:04

97: Anatomy of the Happiest App on Earth

3/8/2024
The Disney experience app is a mobile engineering marvel. Jon and Allan take a slightly less technical conversation on the anatomy of an app and geek out over the happiest app on earth. In this episode, Jon and Allan discuss their recent vacations to Belize and Disney World. They dive into the features and functionality of the Disney mobile app, which allows users to book trips, manage reservations, and access various services. They highlight the seamless integration of the app with hotel check-in, mobile food ordering, and car locator features. The chapter also explores the user interface and navigation of the app, as well as the integration of Magic Bands and Apple Wallet for a convenient and magical experience. The episode concludes with a discussion on the Genie Plus and Lightning Lanes services, as well as the animated passes in Apple Wallet. Disney's attention to detail is evident in their interactive photo experiences, such as the PhotoPass and on-ride photos. The app allows users to book Lightning Lane reservations and participate in scavenger hunts, creating a seamless and engaging experience. Disney's crowd management and analytics ensure a smooth flow of visitors throughout the park. The backend infrastructure supporting these features is a marvel in itself. Overall, Disney's gamification approach enhances the park experience while providing value for the price. In this episode, Allan and Jon discuss the impressive features and functionality of the Disney mobile app. They highlight the interactive droids that react to Bluetooth events in the park and the immersive experience they provide. The conversation then delves into the magic of Disney's app, including its use of Google Maps for detailed mapping and navigation. They also explore the use of Magic Bands for child safety and the seamless integration of various features within the app. The discussion touches on the technical challenges faced by Disney and the solutions implemented to ensure a smooth user experience. The episode concludes with a summary of the main takeaways and a mention of Bluetooth plugin packages for developers interested in similar functionality. Takeaways The Disney mobile app offers a wide range of features and functionality to enhance the vacation experience. The app seamlessly integrates with hotel check-in, mobile food ordering, and car locator features for a convenient and efficient experience. The user interface and navigation of the app are well-designed, providing easy access to information and services. The integration of Magic Bands and Apple Wallet allows for a seamless and magical experience throughout the park. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Vacation experiences: Belize and Disney 03:10 The Disney app and its features 05:01 Booking a trip and managing reservations 07:22 Hotel reservations and check-in 08:17 Mobile food ordering 09:15 Car locator feature 11:43 User interface and navigation 14:12 Magic Band and Apple Wallet integration 19:58 Express pass and Magic Band 21:29 Animated passes in Apple Wallet 24:13 Attention to Detail 25:20 PhotoPass and Cast Members 26:16 Interactive Photos 27:13 Real-Time Photo Processing 28:19 On-Ride Photos 29:29 Scavenger Hunts and App Interactions 32:46 Crowd Management and Analytics 38:24 Lightning Lanes and Ride Availability 44:41 The Backend and Infrastructure 46:05 The Gamification Experience 47:10 Interactive Droids and Bluetooth 48:09 The Magic of Disney's App 51:12 Disney's Use of Google Maps 53:18 Magic Bands and Child Safety 55:06 Technical Challenges and Solutions 59:00 Cellular Connectivity and Redundancy 01:01:42 The Marvel of Disney's Mobile App 01:04:57 Conclusion and Plugin Packages

Duration:01:08:23

96: Selling Jon on Reactive Extensions

3/1/2024
In this episode, Jon and Allan discuss Reactive Extensions (Rx) and its advantages over traditional event handling. They start by addressing Jon's resistance to dependency injection and his concerns about taking dependencies on external libraries. Allan introduces Rx as a solution to handle events more effectively and efficiently. They explore the benefits of Rx, such as composability, filtering, and transforming events. The conversation delves into the implementation of Rx in different platforms and its integration with Maui. They also discuss challenges and solutions in using Rx, including canceling requests and validating input. Overall, the episode highlights the power and versatility of Rx in simplifying event handling and improving code readability. In this conversation, Jon and Allan discuss Reactive UI and Reactive Extensions. They explore the features and benefits of Reactive UI.net and how it simplifies event handling and data binding in UI development. They dive into topics such as throttling and transforming events, filtering empty or invalid values, canceling and restarting events, and handling complex use cases. They also discuss the challenges and limitations of Reactive Extensions, including assembly size and reflection usage. The conversation concludes with a discussion on identifying use cases for Reactive UI and plans for future discussions on the topic. Takeaways Reactive Extensions (Rx) is a powerful library that simplifies event handling and provides a more composable and efficient way to work with events. Rx offers advantages over traditional event handling, such as the ability to filter, transform, and compose events, as well as handle asynchronous operations. RxUI is an open-source project that integrates Rx with Maui and other platforms, providing additional features and simplifying event handling in user interfaces. Using Rx can help address common challenges in event handling, such as memory leaks, complex event patterns, and managing asynchronous operations. Regular expressions can be used with Rx to validate and filter input, improving the quality and reliability of user interactions. Reactive UI.net simplifies event handling and data binding in UI development. Reactive Extensions provide powerful tools for manipulating and transforming events. Throttling and filtering events can improve performance and reduce unnecessary processing. Reactive UI and Reactive Extensions have limitations and may require careful consideration in certain scenarios. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Small Talk 01:07 Jon's Resistance to Dependency Injection 02:21 Introducing Reactive Extensions (Rx) 03:45 Advantages of Rx and Issues with Events 08:34 Rx in Different Platforms 10:00 Transforming and Filtering Events with Rx 15:29 Understanding Observables and Observers 19:21 Simplifying Event Handling with Rx 22:21 RxUI and its Integration with Maui 25:03 Challenges and Solutions in Using Rx 28:26 Implementing a Search Feature with Rx 31:03 Handling Continuous Typing and Caching Results 33:32 Validating Input with Regular Expressions 34:09 Introduction to Reactive UI and Reactive Extensions 34:38 Exploring Reactive UI.net 35:11 Throttling and Transforming Events 36:25 Distinct Until Changed 37:12 Filtering Empty or Invalid Values 37:45 Subscribing to Events 38:13 Canceling and Restarting Events 39:05 Complex Use Cases and Limitations 40:08 Using Reactive Extensions with Async 41:23 Challenges with Reactive Extensions 42:21 Assembly Size of System.Reactive 43:16 Reflection and Dynamic Usage 44:34 Considerations for Mobile Apps 48:35 Benefits of Reactive UI in UI Development 51:08 Identifying Use Cases for Reactive UI 54:04 Reactive UI and Reactive Extensions as Picks of the Week 55:06 Conclusion and Future Discussion

Duration:00:57:37

95: Xamarin.Forms to MAUI

2/23/2024
In this episode, Jon and Allan discuss the migration experiences from Xamarin.Forms to .NET MAUI. They highlight the opportunity for architectural improvements during the migration process, such as cleaning up code and removing static untestable components. They also explain the evolution of Xamarin.Forms into .NET MAUI and the introduction of handlers. The benefits of the single project structure and the ease of migrating third-party libraries are discussed. The conversation also covers the customization of entry handlers and the migration of resources, including images and fonts. This conversation covers various challenges and solutions related to image management, including the use of vectors, app icons, and splash screens. It also discusses the migration process from Xamarin.Forms to .NET MAUI, highlighting the importance of a methodical approach. The conversation concludes with a recommendation for the Maui Community Toolkit as a valuable resource for developers. Takeaways Migrating from Xamarin.Forms to .NET MAUI provides an opportunity to improve the architecture of the app. The introduction of handlers in .NET MAUI allows for cleaner and more testable code. The single project structure in .NET MAUI simplifies the development process and improves compile times. Migrating third-party libraries may require finding alternatives or porting them to .NET MAUI. Customizing entry handlers and migrating resources, such as images and fonts, can be done more easily in .NET MAUI. Image management in mobile app development can be challenging, especially when dealing with different resolutions and densities. Using vectors can simplify image management by allowing for easy scaling to different sizes. App icons and splash screens can be generated automatically in .NET MAUI, reducing the manual effort required. When migrating from Xamarin.Forms to .NET MAUI, it is important to approach the process methodically, starting with dependencies and gradually bringing over pages and components. People Hosts: Jon Dick, Allan Ritchie Chapters 00:00 Introduction and Migration Experiences 01:11 Opportunity for Architectural Improvements 03:16 Evolution of Xamarin.Forms to Maui 06:27 Architecture of Maui Handlers 09:30 Benefits of Single Project Structure 13:56 Migration of Third-Party Libraries 18:13 Handling Dependency Service and Renderers 25:09 Porting Plugins and Controls 32:48 Customizing Entry Handlers 35:45 Migration of Resources 37:23 Image Management Challenges 39:25 Building a Solution: Resize-itizer 41:03 Vector Images in Maui 44:05 App Icons and Splash Screens 46:38 Migrating Resources to Maui 49:35 Font Handling in Maui 51:37 Replacing Frames with Borders 53:10 Avoiding Tap Gesture Issues with Stack Layouts 55:12 Namespace Changes in XAML 56:45 Methodical Migration Process 59:28 Package of the Week: Maui Community Toolkit

Duration:01:01:41

94: Anatomy of an App

2/16/2024
In this episode, Jon and Allan discuss the process of building a mobile app, starting with the analogy of building a lightsaber at Disney. They explore the anatomy of a mobile app, including the use of MVVM architecture and the importance of gluing logic together. They also delve into navigation and the use of Shell in Xamarin.Forms. The conversation then shifts to the benefits of using dependency injection in app development and the considerations for cross-platform development. In this episode, Allan and Jon discuss various aspects of app development, including dependency injection, core services, and cross-platform services. They emphasize the importance of creating a base set of services and thinking outside the box when faced with UI design challenges. They also highlight the significance of solving business problems first and introduce Prism as a comprehensive app architecture framework. Takeaways Building a mobile app involves various components, including the user interface, logic, and navigation. MVVM (Model-View-ViewModel) architecture is a popular approach for separating the presentation logic from the user interface. Shell in Xamarin.Forms provides a convenient way to handle navigation in mobile apps. Dependency injection (DI) can simplify the management of dependencies and improve testability in app development. Cross-platform development allows for code sharing and reduces development time and effort. Use dependency injection and service injection to manage dependencies and improve code maintainability. Create a base set of services that are core to every page in your app to simplify dependency injection. Think outside the box and consider alternative approaches when faced with UI design challenges. Solve business problems first and focus on reusability only when patterns emerge. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Building a Lightsaber 03:11 Anatomy of a Mobile App 08:15 Gluing Logic with MVVM 17:36 Navigation and Shell 23:42 Using Dependency Injection 30:34 Cross-Platform Considerations 33:24 Dependency Injection and Service Injection 34:35 Core Services and Cross-Platform Services 36:25 Creating a Base Set of Services 37:11 Anatomy of a Maui App 38:19 The UI as the Top Bun 39:17 The Importance of Connectivity 41:14 Thinking Outside the Box in App Development 44:48 Navigating UI Design Challenges 48:09 Custom Controls and Creative Solutions 54:29 Solving Business Problems First 58:38 Prism: A Comprehensive App Architecture Framework

Duration:01:01:18

93: These aren't your grandma's Templates

2/9/2024
In this episode, Jon and Allan discuss the importance of templates for mobile app development. They explore the challenges of remembering details like Android manifest and info.plist, and how templates can help simplify the process. They also discuss the default templates in Maui and the benefits of item templates in VS Code. The conversation covers the balance between complexity and simplicity in templates, and the value of custom templates for saving time. They also touch on managing permissions and entitlements, and the power of MSBuild and CSProj files in customizing projects. The episode concludes with a discussion on the benefits of community templates. In this episode, Jon and Allan discuss different types of templates available for building mobile apps with .NET Maui. They cover item templates, Maui templates, solution templates, Visual Studio templates, VS Code templates, and command line templates. They also talk about the benefits of creating custom templates and how they can help standardize development practices within an organization. Takeaways Templates are essential for simplifying mobile app development and helping developers remember important details. Default templates in Maui and item templates in VS Code provide a starting point for building mobile apps. Custom templates can save time and help manage permissions and entitlements. MSBuild and CSProj files offer powerful customization options for projects. Community templates provide additional resources and options for developers. There are various types of templates available for building mobile apps with .NET Maui, including item templates, Maui templates, solution templates, Visual Studio templates, - VS Code templates, and command line templates. Item templates are used to add specific elements, such as XAML pages or views, to an existing project. Maui templates provide a starting point for building cross-platform apps with .NET Maui and include pre-configured project structures and dependencies. Solution templates allow developers to generate a complete solution with multiple projects and project references. Visual Studio templates offer a rich mechanism for creating templates with dynamic interfaces and advanced features. VS Code templates focus on command line interactions and provide a more lightweight and streamlined experience. Command line templates are used with the 'dotnet new' command and offer a simple and flexible way to generate project structures. Creating custom templates can help standardize development practices within an organization and simplify the onboarding process for new projects. Using templates can save time and effort by automating repetitive tasks and providing a consistent starting point for app development. Consider using existing templates or creating your own templates to improve productivity and maintain coding best practices. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 00:31 The Importance of Templates for Mobile Apps 01:38 Default Templates in Maui 02:35 Item Templates in VS Code 03:28 The Challenge of Remembering Details 04:11 Customizing Templates 05:38 Balancing Complexity and Simplicity in Templates 06:55 Different Needs for New and Experienced Users 07:45 Creating Custom Templates 08:23 Managing Permissions and Entitlements 09:44 The Power of Templates in Saving Time 11:05 The Challenge of Changing Requirements 13:21 Managing Permissions in Templates 14:42 Working with Templates in Different Environments 15:23 Using Conditional Logic in Templates 17:42 Generating Entitlements in Templates 19:14 Simplifying Project Files 21:17 The Power of MSBuild and CSProj Files 23:01 Overcoming Fear of Project Files 25:21 Using Project Files for Customization 26:41 The Benefits of Plugin Templates 30:51 Including Popular Packages in Templates 32:33 The Value of Community Templates 33:32 Introduction to Templates 34:05 Different Template Options 35:39 Item Templates 36:09 Maui...

Duration:00:48:22

92: Background Tasks can be Shiny

2/2/2024
In this episode, Jon and Allan discuss backgrounding in mobile development. They start by reviewing the virtual list view and how it solved Allan's problem. Then, Jon reveals the story behind his nickname 'Red.' The conversation then shifts to backgrounding in mobile development, covering common scenarios such as data synchronization, image uploads, and real-time GPS. They explore the different approaches to backgrounding on Android and iOS, including the use of services, broadcast receivers, foreground services, and job scheduling. Finally, they discuss background transfers on both platforms. This episode explores background transfers, background tasks, and code execution in mobile apps. The hosts discuss the challenges of handling slow APIs, managing state in background jobs, and scheduling one-off and periodic jobs. They also delve into the intricacies of background GPS in iOS and Android, as well as the considerations for background tasks in Windows. The episode concludes with a brief mention of background tasks in CarPlay and Android Auto. Takeaways Backgrounding in mobile development is the ability to execute code when an app is not in the foreground. Common scenarios for backgrounding include data synchronization, image uploads, and real-time GPS. On Android, backgrounding can be achieved using services, broadcast receivers, foreground services, and job scheduling. On iOS, backgrounding is more restricted, with foreground services and background transfers being the primary options. Developers should consider the specific platform guidelines and limitations when implementing backgrounding functionality. Background transfers are useful for uploading or downloading large files or data sets. Managing state in background jobs can be challenging, but there are various ways to handle it, such as using preferences or messaging frameworks. Background GPS in iOS and Android allows for tracking location and other data, but it should be used judiciously to avoid excessive battery drain. Background tasks in Windows can be achieved using WinRT APIs, but they may be less relevant in desktop scenarios. Consider the specific use case and user needs before implementing background tasks, and be mindful of the impact on battery life and data usage. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Virtual List View 05:28 The Story Behind the Nickname 'Red' 08:50 Backgrounding in Mobile Development 19:21 Backgrounding on Android 27:45 Backgrounding on iOS 30:31 Background Transfers on Android 31:55 Background Transfers on iOS 32:42 Background Transfers 33:45 Handling Slow APIs 34:38 Background Tasks in iOS 13 36:46 Managing State in Background Jobs 37:45 One-Off and Scheduled Jobs 40:20 Background Execution in iOS 41:36 Passing State to Background Jobs 44:22 Challenges of Data Synchronization 45:45 Background Execution in Windows 46:19 Background GPS in iOS 47:39 Background GPS in Android 51:53 Considerations for Background Tasks 55:12 Background Tasks in CarPlay and Android Auto

Duration:00:58:28

91: ListViews and CollectionViews

1/26/2024
In this episode, Jon and Allan discuss the challenges and history of implementing lists in mobile apps. They start by addressing a listener question about the difference between CLI commands in MAUI and other UI frameworks. They then dive into the topic of dealing with lists in mobile apps, including the challenges of performance and dynamic sizing. They explore the history of list implementations on different platforms and the limitations of the current CollectionView in MAUI. They also discuss alternative list view controls and the misuse of observable collections in list views. In this episode, Allan and Jon discuss various aspects of building performant lists in mobile apps. They cover topics such as using observable collections for data in motion, optimizing list performance, choosing the right list control, and introduce the Virtualized List View plugin. Takeaways Implementing lists in mobile apps can be challenging due to performance and dynamic sizing issues. The history of list implementations on different platforms, such as ListView, RecyclerView, and UICollectionView, has influenced the current state of CollectionView in MAUI. The current CollectionView in MAUI tries to do too much and can be complex to use in certain scenarios. Alternative list view controls, such as Sharpnado and Syncfusion, provide different approaches and features for handling lists in mobile apps. Observable collections are often misused in list views, leading to performance issues. It is important to use them appropriately and consider using a regular list when the data is not changing frequently. Observable collections are useful for handling data in motion, such as real-time updates or changing distances. Optimizing list performance should be done based on actual needs and user behavior, rather than prematurely optimizing for potential issues. Consider the specific requirements of your app when choosing a list control, and don't be afraid to explore alternative solutions like Blazor or web technologies. The Virtualized List View plugin by Jon is a powerful tool for building performant lists in Xamarin.Forms and can be a great solution for complex scenarios. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Weather 01:14 Listener Question: CLI Command in MAUI 05:36 Topic: Dealing with Lists in Mobile Apps 19:35 History of List Implementations 25:51 Challenges with Collection View in MAUI 30:17 Alternative List View Controls 35:38 Observable Collections and List Views 39:18 Observable Collection and Data in Motion 46:11 Optimizing List Performance 52:26 Choosing the Right List Control 56:25 Virtualized List View Plugin 01:00:53 Optimizing List Performance (Continued) 01:04:08 Conclusion and Plug-in of the Week

Duration:01:06:36

90: Push Notifications are Hard!

1/19/2024
Summary In this episode, Jon and Allan discuss the complexities of implementing push notifications on iOS and Android. They delve into the history of push notifications and the challenges developers face in tackling this topic. They explore the setup and configuration process for both platforms, including the use of certificates and entitlements on iOS and the use of Firebase on Android. They also discuss the lifecycle of notifications, handling background execution, and the differences between iOS and Android in terms of permissions and notification handling. In this episode, Jon and Allan discuss various aspects of push notifications on Android, including permissions and changes, setting up notifications, specifying intents in notification payloads, silent notifications, sending notifications to tags, handling multiple devices, and the Shiny Push library. They also touch on source generators and boilerplate code. Overall, the conversation provides valuable insights into the complexities and best practices of implementing push notifications on Android. Takeaways Push notifications are a complex topic that require careful setup and configuration on both iOS and Android. Developers face challenges in implementing push notifications due to the differences between platforms and the evolving nature of the technology. The setup and configuration process involves obtaining certificates and entitlements on iOS and using Firebase on Android. The lifecycle of notifications and the handling of background execution differ between iOS and Android. Permissions and changes in Android, such as the introduction of post-notifications, add another layer of complexity to push notification implementation. Permissions and changes in Android can impact the implementation of push notifications. Notifications on Android can be set up to route directly to an activity by specifying an intent in the notification payload. Silent notifications on Android can be used to wake up the app and perform background tasks. Sending notifications to tags allows for logical grouping and targeted delivery on Android. Handling multiple devices and ensuring notifications are received on all devices can be challenging. The Shiny Push library simplifies the implementation of push notifications on Android. Source generators can help reduce boilerplate code and make implementation easier. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Tackling Hard Problems 04:00 History of Push Notifications 08:30 Setup and Configuration on iOS 13:02 Registering for Notifications on iOS 15:22 Lifecycle of Notifications on iOS 17:43 Silent Notifications on iOS 19:27 Handling Background Execution on iOS 22:06 Complexity of Cross-Platform Implementation 24:19 Setup and Configuration on Android 28:35 Handling Notifications on Android 32:19 Permissions and Changes in Android 33:16 Permissions and Changes 35:27 Setting Up Notifications on Android 36:43 Specifying Intents in Notification Payloads 38:19 Silent Notifications on Android 41:48 Sending Notifications to Tags on Android 44:29 Handling Multiple Devices on Android 49:15 Shiny Push Library 52:21 Server-to-Server Notifications 56:08 Source Generators and Boilerplate 57:44 Plugin Pick: Shiny Push

Duration:01:00:05

89: Bound for greater Bindings

1/12/2024
This conversation discusses the concept of bindings in a mobile.NET, Maui world. Bindings are used to integrate native libraries into the.NET ecosystem. The conversation covers the challenges and complexities of creating bindings for Android and iOS platforms. It explores the differences between Android X libraries and platform APIs. The concept of slim bindings is introduced, which involves creating a simplified interface for interacting with native libraries. The conversation also touches on the use of platform channels for message passing between.NET and native code. The future of bindings and the need for improved tools and processes are discussed. The conversation discusses the challenges and considerations when integrating platform channels in Xamarin projects. It explores the difficulties of referencing native frameworks and dependencies in Xcode projects and suggests the need for improved tooling to simplify the process. The conversation also delves into the complexities of handling AndroidX dependencies and the potential issues with duplicate libraries. Additionally, it highlights the concept of platform channels in Maui and the potential for creating a seamless integration experience. The recommended plugin for this episode is Xamarin Binding Helpers. Plugins, Packages, and Products This week we're talking about Xamarin.Binding.Helpers (https://github.com/Redth/xamarin.binding.helpers) which helps make it easier to create slim bindings on Android, as well as Platform Channels (https://github.com/Redth/Microsoft.Maui.Platform.Channels) which is an experiment for creating a message passing interface between native code and .NET MAUI apps. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Understanding Bindings in a Mobile.NET, Maui World 02:00 Projections of Native APIs into the Managed.NET World 03:41 The Evolution of Bindings 04:06 The Challenge of Android X Libraries 05:00 Dealing with Bindings in Xamarin 06:07 The Complexity of Android Libraries 07:03 Creating Android Bindings 07:30 The Process of Android Binding 08:16 Challenges with Java and Kotlin Libraries 09:08 Handling Complex Inheritance in Java and Kotlin Libraries 10:22 The Sprawl of Android X Libraries 11:31 The Challenges of Binding Android X Libraries 12:09 The Simplicity of Binding Platform APIs 13:16 The Differences Between iOS and Android Bindings 14:22 Creating iOS Bindings 15:48 The Challenges of Objective-C and Swift Libraries 18:36 The Need for Slim Bindings 20:00 The Challenge of Dependency Chains 21:54 The Concept of Slim Bindings 23:46 The Advantages of Slim Bindings 27:11 Determining When to Bind the Whole Library 29:34 Debugging Slim Bindings 34:52 The Concept of Platform Channels 38:58 Performance Considerations of Platform Channels 40:37 The Future of Bindings 40:46 Integration with Xcode Project 42:41 Challenges with Tooling 46:48 Handling AndroidX Dependencies 50:15 Platform Channels in Maui 53:00 Plugin Recommendation: Xamarin Binding Helpers

Duration:00:53:48

88: Return of Gone Mobile and the State of .NET MAUI

1/5/2024
Summary In this episode, Jon and Allan discuss the state of .NET Maui, the challenges of mobile development, and the benefits of using Blazor WebView in Maui apps. They also talk about the evolution of the Mono runtime, the use of handlers in Maui, and the transition from custom renders to source generators. Overall, they highlight the improvements and advancements in the .NET Maui framework and its potential for creating cross-platform mobile apps. In this episode, Jon and Allan discuss app profiling and performance optimization, highlighting the use of tools like DS router and DS dotnet trace to profile apps and identify performance issues. They emphasize the importance of measuring and optimizing early in the development process to avoid potential problems. The conversation then shifts to the introduction of a new segment called 'Plugin Package or Product,' where they showcase a library called compiled bindings that enhances the XAML experience by providing additional operators and reducing verbosity. They express their interest in incorporating such concepts into the core product. The episode concludes with a call to action for listeners to subscribe, leave reviews, and provide topic suggestions for future episodes. Takeaways The .NET Maui framework has made significant progress, with improvements in tooling, performance, and support for modern mobile app development. Blazor WebView in Maui allows developers to leverage their existing Blazor skills and codebase to build hybrid mobile apps. The transition from custom renders to handlers in Maui simplifies the development process and improves performance. Source generators in Maui enable automatic code generation, reducing the need for manual coding and improving productivity. App profiling and performance optimization are crucial for identifying and resolving performance issues in apps. Tools like DS router and DS dotnet trace can be used to profile apps and gather trace files and speed scope logs for analysis. Early measurement and optimization can help prevent performance issues and improve the overall user experience. Compiled bindings is a library that enhances the XAML experience by providing additional operators and reducing verbosity, making it easier to work with XAML. Plugins, Packages, and Products This week we're talking about Compiled Bindings: https://github.com/levitali/CompiledBindings which provides {x:Bind} Markup Extension for WPF, MAUI and Xamarin Forms. Chapters 00:00 Introduction and Changes to the Podcast 06:17 State of .NET Maui 09:24 Dependency Injection in .NET Maui 11:12 Evolution of the Mono Runtime 13:14 Challenges of Mobile Development 19:22 Long-Term Release of .NET Maui 21:20 Blazor Hybrid App 23:43 Benefits of Blazor WebView 25:49 Mixing Blazor and Maui 31:35 Handlers in .NET Maui 35:13 Porting Custom Renders to Handlers 37:03 Source Generators in .NET Maui 38:56 App Profiling and Performance Optimization 41:29 Plugin Package or Product: Compiled Bindings 47:04 Closing Remarks and Call to Action

Duration:00:48:48

87: Couchbase Mobile Update with Robert Hedgpeth

7/10/2019
It's been a few years since we've talked Couchbase on the show, so with their recent release of Couchbase Mobile 2.5 we thought we'd bring Robert Hedgpeth on to catch us up! Special Guest: Robert Hedgpeth.

Duration:00:50:30

86: Building PepTown with Eric Sink

4/16/2019
You may know Eric Sink from the database syncing product Zumero, or perhaps the source control versioning system SourceGear. Now, Eric is building a platform for High School sports fundraising, and he's doing it in .NET. Special Guest: Eric Sink.

Duration:00:52:06

85: Creating Low-Code Apps Using OutSystems with Stacey Levine

3/6/2019
OutSystems allows you to do some pretty amazing things with Low to No Code. We talk to Stacey Levine about their platform to see just how much you an accomplish without coding! Special Guest: Stacey Levine.

Duration:01:04:44

84: Creating Apps From Spreadsheets Using Glide with Jason Smith and Mark Probst

2/11/2019
Creating apps from spreadsheets? You bet! In this episode we're joined by Jason Smith and Mark Probst, formerly of Xamarin/Microsoft, to talk about their new endeavor called Glide. Glide's goal is to let you build beautiful, data-powered apps quickly and easily, so tune in to learn what it's all about! Special Guests: Jason Smith and Mark Probst.

Duration:00:47:18

83: Diving into GrialKit and Gorilla Player with UXDivers

1/15/2019
We finally sit down with Leonardo and Diego from UXDivers to talk about their products GrialKit and Gorilla Player. GrialKit is a collection of Xamarin.Forms user controls, templates, pages, and basically a really simple way to make your app look great. Gorilla Player lets you live preview and hot reload XAML from your Xamarin.Forms products on a device or simulator. Special Guests: Diego Rivero and Leonardo Rodriguez.

Duration:00:59:16

82: Building Fabulous Apps Using F# with Jim Bennett

12/31/2018
It's been awhile since we've had a good F# discussion, so for our final episode of 2018 we decided to fix that. Join us as we talk to Jim Bennett about the latest and greatest in the world of F# and how it's becoming a better option than ever before for building mobile apps! Special Guest: Jim Bennett.

Duration:00:52:50

81: Shiny and New at Microsoft Connect 2018

12/10/2018
We discuss and recap some of the more interesting highlights from Microsoft Connect 2018.

Duration:00:55:21

80: Building IoT Apps using .NET and Meadow with Bryan Costanich

11/12/2018
Bryan can finally share what he's been working on, and "IoT" is full of .NET goodness! On this episode we talk to Bryan Costanich about Meadow, a new microcontroller where .NET is king. This isn't your typical microcontroller, give us a listen! Special Guest: Bryan Costanich.

Duration:01:00:35

79: Flutter with Thomas Burkhart

10/29/2018
Thomas Burkhart talks with us about what Flutter is, what it's like to program in Dart, and the pro's and con's of Flutter as a mobile development platform. Special Guest: Thomas Burkhart.

Duration:01:01:48