MobileChart

Matching the features available for iOS, MobileChart lets you create a wide variety of charts to show in your Android app.

MobileColorPicker

This new control, as its name suggests, lets you use the system color picker to select a color.

MobilePDFViewer

Last year Android added PDFDocument support for creating your own PDFs, and now we’ve added MobilePDFViewer to give you an easy way to show PDF document files from your Android apps.

Zip/Unzip

The FolderItem class now supports the Zip and Unzip methods to make it simple to compress and uncompressed Zip files.

Android Keeps Getting Better

There are also improvements to MobileTabPanel, MobileTextArea, MobileSlider, MobileScrollableArea, Barcode and more. With each release, Android gets closer to feature parity with iOS!

And of course, we continue to squash framework and compiler bugs.

Be sure to check out the full release notes for all the details!

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

In previous releases, the MobileSharingPanel control allowed your app to share a single picture, a URL, or text with any registered iOS system service or app. Now, you can share multiple pictures at once and also share as many files as you want (including entire folders)!

To share multiple pictures, we’ve overloaded the SharingPanel.SharePicture method so its first parameter can accept an array of pictures. It’s that simple. When the panel appears, the same action will apply to the whole group.

For sharing files, you now have two methods available:

MobileSharingPanel.ShareFile(file As FolderItem, parentScreen As MobileScreen = Nil, parentControl As MobileUIControl = Nil)

MobileSharingPanel.ShareFile(files() As FolderItem, parentScreen As MobileScreen = Nil, parentControl As MobileUIControl = Nil)

The first method is designed to share a single FolderItem instance. If that FolderItem points to a folder, the entire contents of the folder will be shared.

The second method accepts an array of FolderItem instances as its first parameter. This is likely the best choice when your app needs to share a group of items from different sources, offering greater flexibility.

Overall, the enhanced SharingPanel is now more powerful and versatile. We’re excited to see how you’ll put it to use in your mobile apps!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

But what about iOSLayoutConstraint instances created in code? Starting with Xojo 2025r2, that’s been improved! Keep reading to learn how.

Of course, there have always been ways to manage iOSLayoutConstraint instances created in code (for example, by storing references to them) so you could interact with them just like the named constraints created at design time. But with Xojo 2025r2, we’ve made that even easier.

The MobileScreen.AddConstraint and MobileUIControl.AddConstraint methods now include an optional name parameter. This means you can assign a name to constraints added in code and later activate, deactivate, or remove them by name, just like design-time constraints!

Of course, you can’t assign the same name to multiple constraint instances on the same screen or UI control. If you try to do so, an UnsupportedOperationException will be raised.

We’ve also overloaded the MobileScreen.RemoveConstraint method to accept a String parameter, allowing you to remove a named constraint directly. No need to keep track of iOSLayoutConstraint instances using property references or other custom methods.

All in all, starting with Xojo 2025r2, you no longer need to implement your own logic to manage constraint instances. This makes it much easier to build responsive, polished UIs that adapt well across platforms and device orientations.

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

1. Define Your Idea

Start by summarizing your app’s purpose in a single, clear sentence. The more concise it is, the better defined your objective will be. This clarity will help guide your screen designs, navigation structure and code architecture.

This sentence can also double as your app’s short description in App Store Connect.

Focus on the essential features that form your app’s Minimum Viable Product (MVP). It’s easy to get sidetracked by new ideas during development. Resist the urge! Instead, keep a list of potential features for future updates and base priorities on user feedback.

2. Choose The Platform(s)

Xojo supports both iPhone and iPad, but your app doesn’t have to. Choose the device type that best fits your app’s use case.

• iPhone apps often support quick, task-based interactions.
• iPad apps are better suited to immersive, content-rich experiences.

To target a specific device only, set the unused layout (iPhone or iPad) to “None” in the App item’s Inspector Panel.

You’ll also need to decide the minimum iOS version to support. Xojo currently defaults to iOS 14.0, but as of writing, over 60% of users are on iOS 18 or later.

3. Prototyping

Xojo’s visual layout editor makes it easy to dive in designing your app. But take time to prototype your app first, especially if it has more than basic functionality.

Use tools like Figma or MockUp, or simply sketch your ideas with pencil and paper. Choose whatever helps you plan best and clearly.

Also, review Apple’s Human Interface Guidelines to align your app with native iOS expectations.

When designing in Xojo, you can fine-tune layout behavior using the iOSLayoutConstraint class to adapt to orientation and screen size changes at runtime.

4. Database Design

Most apps use a database. For local storage on iOS, use SQLiteDatabase, and save your database file in SpecialFolder.Documents.

Two key best practices:

• Add a Metadata table to track the database schema version.
• Create a custom SQLiteDatabase subclass to manage all read/write operations in one place.

This setup allows you to always know which version is installed on the user’s device and to react accordingly as your app evolves.

5. Graphic Resources

For icons, buttons and tab bar images, use Picture.SystemImage with symbols from Apple’s SF Symbols app. These scale beautifully across devices and adapt to light/dark mode. Just ensure compatibility with your minimum iOS version.

When using custom images, add them at multiple resolutions for optimal display across all screen sizes.

Typography also matters. Use system fonts thoughtfully, ideally no more than two font families. Vary sizes and weights to establish content hierarchy. Keep text readable with a minimum font size of 11pt.

Tip: When testing in the Simulator, set the window to physical size (Simulator > Window > Physical Size) to preview real-world readability.

6. Localization and Accessibility

Nothing prevents you from publishing an app in a single language, whether it’s your native language or English; but supporting multiple languages can increase downloads by over 100x.

Start localizing early to avoid design issues later. Add a module to your Xojo project with localized String constants for all app text, and enable the “Localized” option for each one.

Suggested languages (in order of impact):

Core: English

High-impact additions: Chinese, Spanish, German, French, Japanese, Italian, Portuguese, Russian, Korean

Also, localize accessibility labels and App Store listings, including screenshots and descriptions, for each supported language.

7. Testing the App

Xojo provides multiple ways to test your app, both from a design and user experience perspective, as well as from a functionality perspective:

• Simulators: Ideal for design, layout and localization testing. You can also use them to take App Store screenshots.
• On-device Debugging: Offers realistic input experience and access to hardware-only features.
• Build to Device: Lets you run the app outside the debugger, simulating real-world use.

Once you’ve finished fixing bugs in your code and app design, move on to testing in the real world by compiling your app and using Xcode to copy that bundle to a physical device. Testing like this, you’ll likely find some optimizations, especially around design and usability.

TestFlight is your gateway to external beta testers. After uploading a build to App Store Connect, create a public link to invite testers. Remember to increment the version number with each new build.

Tip: Add ITSAppUsesNonExemptEncryption = False in your Property List to streamline build approvals.

8. Publish it!

Publishing with Xojo is straightforward. The most time-consuming step is preparing your App Store Connect listing including text, artwork, screenshots, keywords and possibly localized pages. Read more about this in my earlier post How to Publish macOS and iOS Apps to the App Store Directly from Xojo.

Make sure you select the correct build when submitting your app for review.

9. Marketing

Something you should be doing simultaneously is preparing the related materials to introduce your app to the world. Start your marketing efforts early. A simple website can significantly boost discoverability. Use it to:

• Provide tutorials and FAQs
• Link to App Store and social media
• Highlight features and updates

Consider creating a YouTube channel for app demos and support videos, and maintain active social media profiles to stay visible.

Don’t forget to take advantage of the Marketing tools provided by Apple to help you create badges, assets, links and even QR codes to promote your app.

10. The Next Steps …

After launch, gather user feedback and track any bugs that slipped through. At this stage, it’s common to manage:

• A public release (on the App Store)
• A development version (next major update)

Save your Xojo iOS project in text format and use a version control system. This helps you manage multiple branches and collaborate efficiently.

To Summarize

Even the simplest iOS apps require a fair amount of time and effort, but thanks to Xojo, both aspects are significantly reduced.

What iOS apps have you created with Xojo? What’s your methodology or any tips you’d like to share? Feel free to comment on the Xojo forum!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Using the new control is similar to how you would use the same type of control in Desktop projects. For example, drag the control from the Library panel and drop it onto the Layout Editor of a Screen, where it will be added to the Tray area.

Next, you need to call the Show method on the MobileColorPicker instance to display it to the user, and implement the ColorSelected event handler to capture the selected color.

Note: This control’s functionality is available only when the app is run on devices with iOS 14 or later (the minimum recommended version for iOS projects starting with Xojo 2025r1).

Modal vs Popover

When calling the Show method without parameters on the MobileColorPicker instance, it will be displayed as a modal panel on both iPhone and iPad devices. If you provide the ParentControl parameter, the MobileColorPicker will be shown as a popover panel on iPad devices. However, on iPhone devices, it will still be displayed as a modal dialog, regardless of the ParentControl parameter.

In Summary

The addition of the MobileColorPicker control in Xojo 2025r1 simplifies color selection in iOS apps, providing a native and intuitive experience for your users. This control makes it easier than ever to implement color pickers in your iOS projects. So, give it a try in your next app, and enhance the user experience!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

In this article, we’ll explore actionable, real-world design principles tailored to the unique needs of solo developers. Whether you’re building your first app or looking to improve your design skills, this guide will give you the tools and confidence to create apps that stand out in today’s crowded market.

Why Design Matters for Solo Developers

Before diving into specific principles, let’s address a fundamental question: Why is design so crucial for solo developers? The answer is simple—Users judge your app within seconds, forming quick impressions that impact their decision to continue using it. A poorly designed app drives users away, no matter how powerful its functionality is. Good design, on the other hand, builds trust, enhances usability, and keeps users coming back.

For solo developers, good design is also a strategic advantage. With limited resources, you can’t compete with big teams on the number of features. But you can compete on delivering a streamlined, delightful user experience (UX).

Core Design Principles for Mobile App Developers

Let’s break down effective mobile app design into manageable, actionable principles. These are specifically geared toward solo developers who need to maximize their impact without burning out.

1. Start with User-Centered Design (UCD)

The foundation of great design is understanding your users. Who are they? What problems are they trying to solve? What do they expect from your app?

Action Steps:

• Create user personas: Develop simple profiles of your target users, outlining their goals, challenges, and preferences. For example, if you’re building a productivity app, your persona might be a busy freelancer who values speed and simplicity.
• Map user journeys: Sketch the step-by-step flow of how users interact with your app. Identify any potential friction points and eliminate them.

Example:

Imagine you’re building a budgeting app. Your user persona might be a young professional who wants to track expenses quickly. A user-centered approach prioritizes features like one-tap expense logging and clear, visual summaries of spending.

2. Keep It Simple and Intuitive

Users shouldn’t need a manual to figure out how to use your app. Simplicity doesn’t just mean fewer features; it means making the most important features easy to find and use.

Action Steps:

• Follow established patterns: Use common design conventions, such as a bottom navigation bar for key actions. Users are already familiar with these patterns, so don’t reinvent the wheel.
• Limit choices: Avoid overwhelming users with too many options or settings. Focus on the core functionality that solves their problem.
• Prioritize clarity: Use simple, descriptive labels for buttons and menus. Avoid jargon or ambiguous terms.

Example:

Take inspiration from apps like Instagram. Its clean design makes it instantly clear how to post a photo, view stories, or explore content. Even as a solo developer, you can achieve a similar level of clarity by focusing on simplicity.

3. Optimize for Mobile First

Mobile screens are small, so every pixel counts. Designing for mobile-first means giving priority to usability on smaller screens before addressing larger screens.

Action Steps:

• Use responsive design: Ensure your app looks and works great on a wide range of screen sizes, from small phones to large tablets.
• Design for touch: Make buttons and interactive elements easy to tap with a finger. Aim for a minimum touch target size of 48×48 pixels.
• Focus on readability: Use legible font sizes (at least 16px for body text) and maintain sufficient contrast between text and background colors.

Example:

Consider a to-do list app. A mobile-first approach designs a clean, vertical layout with large, tappable checkboxes, ensuring users can quickly mark tasks as complete on the go.

4. Embrace Visual Hierarchy

Visual hierarchy refers to the arrangement of elements to guide users’ attention. When done well, users understand what’s most important at a glance.

Action Steps:

• Use size and color strategically: Make primary actions (e.g., “Submit” buttons) larger and more visually distinct than secondary actions.
• Group related elements: Use spacing to visually group related items, such as form fields or menu options.
• Leverage typography: Use different font sizes and weights to create contrast between headings, subheadings, and body text.

Example:

In a fitness app, display the user’s daily step count in a bold, colorful header, while less critical information (e.g., weekly trends) appears in smaller, subdued text below.

5. Focus on Performance and Speed

No one likes a slow app. Performance is a key part of the user experience, and it’s especially important for mobile apps, where users expect instant responsiveness.

Action Steps:

• Optimize assets: Compress images and use vector graphics where possible to reduce load times.
• Minimize animations: While animations can enhance UX, overusing them slows down your app. Use them sparingly and purposefully.
• Test on real devices: Don’t rely solely on simulators. Test your app on actual devices to ensure smooth performance.

Example:

If you’re building a weather app, users expect the current weather to load quickly. Preload data where possible and optimize your API calls for speed.

6. Iterate and Test Continuously

Design is an iterative process. Even the best initial design can be enhanced through user feedback and continuous refinement.

Action Steps:

• Start with a minimum viable product (MVP): Focus on the core functionality and get it into users hands quickly.
• Gather feedback: Use surveys, app store reviews, or in-app feedback tools to understand what users like and dislike.
• Refine based on data: Analyze user behavior (e.g., which features are most used) and improve accordingly.

Example:

When developing a language learning app, you might discover that users struggle with navigation. Based on feedback, simplify the menu structure or add tooltips to guide new users.

Tools to Simplify Design for Solo Developers

As a solo developer, you don’t need to reinvent the wheel. Leverage tools that streamline the design process:

• Figma: A powerful design tool for creating wireframes and prototypes.
• Xojo: Xojo’s drag-and-drop interface, combined with its easy-to-learn language, makes creating mobile apps across different form factors straightforward.
• Canva: Great for creating simple, clean graphics for your app.

Conclusion: You’ve Got This!

Designing a mobile app as a solo developer is no small feat, but by following these principles, you can create apps that are both functional and enjoyable to use. Remember to start with your users in mind, focus on simplicity and clarity, and continuously refine your work based on feedback.

Your Next Step: Take a look at your current project (or start a new one!) and apply at least one of the principles discussed in this article. Need a mobile app development platform? Check out Xojo for an intuitive, developer-friendly way to bring your app ideas to life.

Layout Editor

The Layout Editor has been enhanced with two settings that can adjust the layout.

The command bar has two toggle buttons. The first one already existed and it is for displaying the layout in portrait (the default) or landscape.

The new toggle button displays the layout in a phone size (the default) or a tablet size. When you switch between any of these toggles, the locking is applied to the controls on the layout.

The layout editor also remembers the selections so that the next time you visit the layout, it will be where you left it. Here you can see a landscape tablet layout:

Default Screen

The App Inspector has an additional Default Tablet Screen property. When your app is launched on a phone or tablet-sized device, the specified screen is what gets displayed.

You can also choose “None” for a default screen if you just want to share a single screen across both types of devices.

If you choose “None” for the Default Phone Screen, then the app won’t launch on a phone. If you choose “None” for a Default Tablet Screen, the app will launch on the tablet using the Default Phone Screen, which matches prior behavior.

Design Considerations

Xojo for Android uses locking to automatically adjust controls on the layout. Locking will work for certain types of layouts that you want to run on both phones and tablets, but may not be sufficient for more complex layouts. In these situations, you are better served by designing completely separate layouts for phone and tablet and then using the above Default Screen properties to show the correct one.

When you need to show additional screens, you can show the phone or tablet screen in code by checking the device using DeviceData.Orientation and DeviceData.UserInterfaceType.

If System.Device.UserInterfaceType = SystemDeviceData.UserInterfaceTypes.Tablet Then
  // Show tablet screen
  myTabletScreen.Show
Else
  // Show phone screen
  myPhoneScreen.Show
End If

When you have multiple screens, it often makes sense to put the UI in containers and then use the containers on the different screens.

You can run your apps on a Tablet emulator for testing (you can create one using Android Studio) or you can debug directly on device. I enabled on-device debugging for a Lenovo Tab M10 Plus 3rd Gen with these steps:

• Go to Settings.
• Select About tablet.
• Tap 7 times in a row on the build number. This enabled Developer options. You may be prompted to enter your PIN.
• Select System and then Developer Options.
• Turn on USB debugging and give it permission.

The tablet will now appear as a debug device in Xojo, allowing you to run your Android projects on it.

What about Chromebook?

Some Chromebooks are able to run Android apps and those that can are also able to run Xojo’s Android apps. Android apps can be installed via the Play Store (give CatsUp a try) or manually, although doing it manually is rather difficult (I have not yet gotten that working on my Chromebook). The Play Store options works well, however. Here’s CatsUp from the Play Store running on my Lenovo 300e Chromebook:

When run on the Chromebook, Android apps can have a size of Phone, Tablet or Resizable. You can see that as an option in the title bar of the above screenshot. For best results you probably want to design your apps for a landscape tablet.

Xojo for Android does not have direct support for Chromebook features at this time, but if there is something you’d like to see, be sure to create an Issue so that we can look into it.

Since Chromebooks are just (low-end) Linux machines at their core, they can technically run Xojo Linux apps (x86 or ARM depending on the Chromebook), but this usually requires some sort of additional Linux installation.

And of course, Chromebooks are typically meant to run web apps, which Xojo can also do quite well.

Eddie’s Electronics Example Project

The Android Eddie’s Electronics example project has been updated to run on both phones and tablets. It makes use of Containers to contain the UI and displays them using screens for the appropriate device type.

Here you can see the Customer screen for a tablet displays the list of customers on the left, with details and invoices on the right.

Compare that to the phone version which has you navigate between that information using separate screens.

Tablet supports opens up a whole other category of users for your Android apps and should be particularly useful to those making bespoke apps for clients.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Getting the Image Metadata

In order to get the metadata from a given image, first retrieve a valid instance from the Picture Class using MobileImagePicker, select Photos or Camera as the image source.

Once we get the Picture instance, for example as the received parameter in the Selected event from the ImagePicker instance, we only need to access its Metadata property. The property will return a Dictionary instance, so we can iterate its entries or convert it to a JSONItem instance for simplicity if all you want to do is store the information. For example, we can use the following fragment of code in the Selected event of the ImagePicker instance:

Var js As JSONItem
Try
  js = New JSONItem(pic.Metadata)
  MessageBox(js.ToString)
Catch e As JSONException

End Try

Assuming that “pic” is the name of the received parameter that points to the user selected (or captured) image, the previous fragment of code will show a dialog with the image metadata.

Getting the Image Location… and Putting it On the Map!

An interesting action could be reading the location data of the selected image and adding an entry on a MobileMapViewer instance. So, for example, again in the Selected event of an ImagePicker instance, we could add the following snippet of code:

If pic <> Nil Then
  ImageViewer.Image = pic
  
  // The metadata is retrieved as a Dictionary, so let's get the
  // metadata from the selected picture
  metadata  = pic.Metadata
  
  If metadata <> Nil Then
    Var jlocation As Dictionary = metadata.Lookup("Location", Nil)
    
    // Getting the Location information (also as Dictionary)
    If jlocation <> Nil Then
      
      // And assigning the Latitude and Longitude
      // values to the properties
      latitude  = jlocation.Value("Latitude").DoubleValue
      longitude = jlocation.Value("Longitude").DoubleValue
      
      // Then, we will show the Picture location on the Map
      Timer.CallLater(100, AddressOf Showlocation)
    End If
    
  End If
  
End If

Latitude and Longitude are Double type properties that have been added to the Screen containing the ImagePicker instance, also added is an ImageViewer instance responsible for displaying the selected image preview, and a MapViewer instance on which the “pin” corresponding to the location of the image will be added.

As you can see, the shared method CallLater of the Timer class is used to invoke the ShowLocation method. This method will be responsible for displaying the actual pin on the map:

Private Sub Showlocation()
  // Let's create a new Location instance from the stored
  // latitude and longitude values in order to add it
  // to the Mapviewer…
  
  Var maplocation As New MapLocation(latitude, longitude)
  MapViewer1.AddLocation(maplocation)
  
  // …and let's make sure the metadata is updated
  // to the viewed image
  ImageViewer.Image.Metadata = metadata
End Sub

The following screenshot shows the outcome of executing the previous code:

Of course, you’ll need to enable the Maps entitlement in the Build Settings > iOS > Capabilities inspector.

Setting the Location in a Picture

Just as we can get the location out of an image, we can also modify it… or set a location to those photographs that we get through the ImagePicker using the Camera source. Assigning a location is very simple:

• Add an instance of MobileLocation to the project (for example the screen where we manage image capture).
• Add the Latitude and Longitude properties of type Double as two new properties on the same screen.
• In the LocationChanged event of the MobilLocation instance assign the values received in the Latitude and Longitude parameters to the properties created previously:

Self.Latitude = Latitude
Self.Longitude = Longitude

• Then, in the Selected event of the ImagePicker instance, use the following snippet of code:

Var d As New Dictionary
d.Value("Latitude") = Self.Latitude
d.Value("Longitude") = Self.Longitude

Var Location As New Dictionary
Location.Value("Location") = d

pic.Metadata = Location

Saving Pictures to Photos

Until now, MobileSharingPanel was probably the go-to option when it came to saving any of the images generated in your iOS Xojo app or images captured with the camera using the ImagePicker. Starting with Xojo 2024r3, you can also use the SaveToPhotos method of the Picture class, which will take care of saving the image while preserving the associated metadata.

So, for example, you will only have to add the following line of code at the end of the previous block so that the captured image is saved with the location:

pic.SaveToPhotos(Picture.Formats.PNG)

However, when using this method on images in your iOS app, make sure to enable the Photos Access capability in the Build Settings > iOS > Capabilities Inspector Panel.

Wrapping-Up

As you have seen, it’s now really easy to get metadata from Picture instances in your Xojo iOS apps, as well as leverage Location information and assign location information to any of existing or new images. Plus, you no longer need to resort to MobileSharingPanel if all you want is your iOS app to save images to the Photos app album on the iOS device.

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

This small update runs exclusively for all Xojo 2024r2+ versions and now offers methods to access a few more system details, such as specific folders (MobileApplication.GetCacheDirXC, GetDataDirXC, GetFilesDirXC, etc.) or methods for checking screen properties like MobileApplication.IsScreenHdrXC, IsScreenRoundXC, ScreenHeightDpXC, or ScreenWidthDpXC.

Feel free to take a look at the developer repository, create feature requests, and provide feedback on extending this extension library.

I’m happy to receive any voluntary financial support for the work I’ve done so far, which you are welcome to share here. You can download the project with many examples at https://github.com/XojoGermany/AndroidDesignExtensions.

Happy coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Although still in Beta, there have been many improvements to Android in the last few releases and in this post I’ll highlight a few things that have been added or improved starting with Xojo 2023r4 and through the recently released 2024r2.

Xojo 2023r4

The final release of 2023 had a lot of Android improvements.

You should always read the entire release notes, which have a wealth of details, but here are some highlights of useful new features that were added to Android in 2023r4:

• Added System.DismissKeyboard method that can be used to hide the virtual keyboard.
• The Ptr type can be used with Declares that call Kotlin Library projects. Other usage of Ptr will result in a compile error.
• There is a new constructor on Font that allows you to load a font file from a FolderItem. Easy custom fonts!
• The Barcode class can be used to scan a variety of barcodes.
• The NewAndroidProject command can be used with IDE scripting to create an Android project.
• MobileApplication.UnhandledException event now better captures the user runtime call stack for Stack() and StackFrame().
• There were many internal changes to the Android framework to get it to have better compatibility with other platforms.
• Improvements to URLConnection data encoding.
• Several JSONItem improvements.
• The Android compiler toolchain was updated to newer versions.
• Added Dependencies property to the Android advanced build settings. This can be used with Declares and Libraries to load any external dependencies they need. Put one dependency per line, an example would be: io.github.bitstorm:tinyzip-core:1.0.0
• Improved compatibility with Android 14.
• Many framework and compiler fixes.

Xojo 2024r1

The first release of 2024 continued the trend of rapid Android improvements.

• MobileApplication.Activated and Deactivating events now work on Android.
• Fixes and improves to several parts of the framework, including:
  • Introspection
  • SQLiteDatabase
  • JSONItem
  • URLConnection
• Many other framework and compiler fixes.

Don’t forgot to review the full release notes!

Xojo 2024r2

The latest Xojo release has plenty of improvements for Android. Some highlights include:

• MobileHTMLViewer field focus is now more reliable.
• TCPSocket is now available.
• Many Graphics properties are now available, including: ShadowBrush, LineCap, LineDash, LineDashOffset, LineJoin, Outline.
• Improved some compiler error messages.
• Many more framework and compiler fixes.

The full release notes are a fun summertime read.

What’s Next for Android?

As you all know by now, we don’t preannounce when things will appear in Xojo releases. We are continually working on adding features and improving Xojo for Android and when new things are ready, they appear in the next scheduled release. The best way to stay on top of what is going to be released soon is to help us with pre-release testing. Remember, if you have an active Xojo Pro license, you have access to a special pre-release section of the forum. If you have a Xojo Mobile license and woudl like to participate in testing please make a request.

With that said, some of the Android features in development include:

• ByRef support
• RegEx classes
• DatabaseConnection
• In-app purchasing support

Related Topics You Might Like

Android Design Extensions 2.5 for Xojo 2024r1

Android Improvements in Xojo 2023r3

Creating an Android Library with Kotlin for Use with Xojo

All Android related blog posts on the Xojo Blog

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Compact Display Style

When using the Compact Display Style, the control adjusts itself to offer two fields for Date and Time selection or just one field in those cases when the Display Mode is set to Date or Time. In any case, this Display Style consumes less real screen space in the UI, making it ideal for more compact interface designs.

For example, use it when designing custom cells for a MobileTable DataSource:

Inline Display Style

On the other hand, the Inline Display Style is ideal for date selection because it renders a calendar in the view that speeds up the date selection by the user. It includes options for rapidly moving among the month or the year to be displayed. This is much faster compared with spinning the wheel for a date in the Wheels Display Style:

Conclusion

We are sure that the new Inline and Compact Display Styles will help polish your UIs and we look forward to seeing how you use them in your iOS apps. Thank you to everyone who filed cases and offered feedback for this release.

Happy coding!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

First of all, if your apps only relies on the Xojo provided iOS framework functionality, then you don’t need to do anything at all. When building or running the iOS app, Xojo will create and add the required PrivacyInfo.xcprivacy file for you.

If you are using Declare calls or rely on iOS third party libraries or plug-ins, then you should check with the developer to know if any of the calls made fall into the Privacy Categories listed by Apple (keep in mind that these can change over time). If so, then it is time to visit the new Privacy Editor available under the Build Settings > iOS section, and click the Settings button in the associated Inspector Panel:

Here you will find the Edit button under the Privacy section. Click on it to bring up the Privacy Editor window:

In the Privacy Editor window, select both the API Type from the entries available in the ComboBox control, plus the associated API Reasons that meet your specific requirements based on the API Type selection.

Of course, you will be able to add as many API Type cards as you may need using the “Add Type” button, or delete any of the previously added cards. If any of your iOS apps share the same Privacy settings, you can simplify the process by creating and saving files in the Privacy Editor. Now you can add those files to your other iOS apps from the Editor via the “Open…” button or by dragging & dropping the file from its current location into the Editor itself.

Once you finish editing the Privacy settings for the iOS project, the PrivacyInfo.xcprivacy file will be created and automatically added when building the iOS app, allowing you to run it the Simulator, any connected iOS device or send it to the AppStore review approval. Learn more about this in the Xojo Documentation.

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Download mp3 or watch on Xojo’s YouTube Channel.

Topics include:

• Photo Tape
• TRAnimation Library
• TRCustomListBox
• WWDC

^{Heavy Action by Audionautix is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Artist: http://audionautix.com/}

The focus of this release was on the integration of pictures in controls, such as MobileButton, MobileDateTimePicker, MobileTextFields, MobileSlider etc.

Let’s take a look at some new possibilities using examples.

Create a MobileButton with a Picture

This is a feature that is in demand in Xojo Issue Tracker and has not yet found its way into the Android framework. So let’s just do it ourselves with the help of the Android Design Extensions.

Create a new Android project. Now copy the Android Design Extensions folder into the project or drag and drop it into the Navigator. Now select Screen1 in the Navigator and add a MobileButton – Button1 – and give it the Opening event. Add the following code to the Opening event:

Me.SetIconXC(SaveSystemImage("camera")) 
Me.SetIconGravityXC(IconGravity.TextStart)

SaveSystemImage is an extension method that returns a FolderItem and saves a Picture.SystemImage with the specified name (here „camera“) in the Documents folder. Why? Xojo Declares do not support Picture as a data type and therefore we have to take the detour and save images once in order to load them into controls via the file path.

You can of course also use any other image and are not restricted to Picture.SystemImage. All Android Design Extensions extension methods that have to do with the display of pictures are prepared for this and expect a FolderItem as a parameter, which must of course be a picture (PNG, JPEG etc.).

SetIconGravityXC ensures that the Picture is displayed in front of the button text. And that’s all there is to it. Execute the project and you have a button with an image.

Tip: If you create a MobileButton subclass, you can cache the FolderItem via Static to create the image file only once. Of course, this only applies to the fact that all button instances of this subclass should always display the same image.

To see how to add an image to a MobileScreen, MobileSlider or MobileSwitch, simply take a look at the Android Design Extensions sample app.

TabPanel Badge Extension

MobileTabPanel tabs now also support text badges. How is it done?

Add a MobileTabPanel – TabPanel1 – to your project and add the Opening event to it with the following code:

Me.SetBadgeTextAtXC(0, "Exclusive")

And that’s all there is to it. The result is as follows:

There are other MobileTabPanel extension methods with which you can customize the badges (color, position, etc.). Give it a try!

TextFields on a New Level

TextFields can also be enhanced with the new Android Design Extensions version.

The SetBoxCornerFamilyXC call now offers the option of choosing whether you want rounded or flattened corners. You can also use SetCursorColorXC to define the color of the cursor for each individual TextField.

TextFields can now also have leading or trailing icons. The helper methods for this are SetStartIconXC and SetEndIconXC, which in turn expect a FolderItem (Picture) as a parameter.

There are many other new declares. Have a look here too.

Feel free to take a look at the developer repository, create feature requests, and provide feedback on extending this extension library.

I’m happy to receive any voluntary financial support for the work I’ve done so far, which you are welcome to share here. You can download the project with many examples here.

Happy Coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

Generate Codes

The ability to generate codes and identify them from images is available as a shared method for the indicated platforms, in desktop and console apps. The latter is interesting because it means that you can use this functionality in web apps deployed on Windows or Mac servers.

Creating QR or Bar128 codes couldn’t be simpler. Since it uses a shared method, it is not even necessary to have previously created an instance of the class, you only need to invoke the method:

Barcode.Image(value As String, width As Integer, height As Integer, type As Barcode.Types = Barcode.Types.QR) As Picture

Where the expected parameters are the following:

• Value: Source text string that will be converted to the indicated code type
• Width: Width of the resulting image with the generated code
• Height: Height of the resulting image with the generated code
• Type: The type of code you want to generate. It can be QR or Bar128; these values are available in the Barcode.Types enumerator

Once the method is invoked, you will obtain an image (Picture) that you can use in your app; or you will receive an InvalidArgumentException if some of the parameters provided are invalid, such as passing an empty text string as the data source.

For example, the following line of code generates a 120 x 120 image corresponding to a QR code with the text provided:

Var p As Picture = Barcode.Image("Xojo Rocks!", 120, 120, Barcode.Types.QR)

Recognize Codes in Images

In the same way it is possible to generate code images from text, it is also possible to recognize up to twelve different types of codes from an image. To do this we will use another shared method of the Barcode class:

Barcode.FromImage(image As Picture) As String()

As you can see, in this case the method will return an array of Strings with the values of the recognized codes. It is possible that the image contains more than one code; but it is also possible that no code could be recognized in the provided image, so it is advisable to check the limits of the received array before proceeding.

For example, this line of code will recognize the codes available in the MyPicture image and return the values in the RecognizedCodes() array:

Var RecognizedCodes() As String = Barcode.FromImage(MyPicture)

Scan Codes

Scanning QR codes (or any of the other supported codes) on desktop is only available for macOS and Windows platforms. This is due to desktop presenting a user interface where you can preview the image captured by the selected camera. You can select the camera to use to scan from those connected to the computer (including, for example, iOS devices in the case of Mac, through Continuity; or Android devices paired with your Windows computer). In the case of Mac, the ability to scan images is only available using macOS 10.15 or higher.

To scan codes directly using any of the cameras connected to the computer it is necessary to have previously created an instance of the Barcode class (for example, drag the class from the IDE Library onto the tray area in the Layout Editor window):

Doing so will add it to the Project Browser where we can select it and implement any of the three available Event Handlers:

• ScanCancelled: The user has canceled the code scanning operation, such as by closing the presented UI window
• ScanCompleted: Receive the value as String corresponding to the code detected by the camera
• ScanFailed: Raised when some type of error has occurred, such as the fact that no camera is detected

To display the code scanning UI, invoke the StartScan method on the created Barcode instance. For example:

Barcode1.StartScan

The scan UI does not close automatically when a code is recognized to allow scanning a series of codes (such as in the case of inventory), so it is also possible to stop the operation by code by calling the StopScan method. For example, you can include this line of code in the ScanCompleted event of the Barcode1 instance after the received value has been processed:

me.StopScan

As expected, invoking the StopScan method from code will close the code scanning UI.

Conclusion

Now you can create all types of applications on macOS, Windows and iOS with the ability to generate and scan QR codes, Barcodes and other types of codes, opening up a wide field of possibilities for Xojo users.

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Usually TTF fonts are used in Android, so the following code will only search for these. Fonts that are globally accessible are located in the /system/fonts/ folder in Android. Using the FolderItem.Children Iterator, we can search for these and generate a visual representation of all fonts in an AndroidMobileTable.

Create a new Android project. Add an AndroidMobileTable (Table1) to Screen1 and lock the control on all four sides of Screen1. Do the same with a Label (Label1) above Table1. Then add the Opening event to Table1 and insert the following code:

Const fontSuffix = ".ttf"

Var folder As FolderItem = New FolderItem("/system/fonts/")
Var counter As Integer

' Iterate over all files within the folder
For Each item As FolderItem In folder.Children

  ' Check for font file (ttf)
  If Not item.Name.EndsWith(fontSuffix) Then Continue

  counter = counter + 1
  ' Create a new Picture for visual representation of the font
  Var pic As New Picture(Me.Width, 50)
  Var g As Graphics = pic.Graphics

  ' Draw font name to the picture
  g.Font = New Font(item, 20)
  g.DrawText(item.Name.Left(item.Name.Length - 4), 5, pic.Height / 2 - g.TextHeight / 2 + g.Font.Ascent)

  Me.AddRow("")

  ' Save Font as RowTag
  Me.RowTagAt(Me.LastAddedRowIndex) = g.Font

  ' Add RowPicture to the row
  Me.RowPictureAt(Me.LastAddedRowIndex, False, 0) = pic
Next

Self.Title = Self.Title + " (" + counter.ToString + ")

Now add the SelectionChanged event to Table1 with the following code:

' Change Label1 font to the selected one 
Label1.TextFont = Me.RowTagAt(Me.SelectedRowIndex)

Now run the project and you will have a complete font selection dialog in your Android app.

The code can be optimized by using the path to the font file as the RowTagAt instead of a Font object and the Font object is only created and assigned in the Table1.SelectionChanged event.

The example project runs from Xojo 2023r4.

Happy Coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

Downloading the Xojo Project

The Xojo project that I demonstrated can be downloaded here. In the zip file, you’ll find the Xojo project file and a “Readme” file. The Readme file includes step-by-step instructions on setting up SuiteTalk REST, a custom NetSuite role, an integration record, and more.

The SuiteQL Query

During the webinar, I spent some time discussing the SuiteQL query that’s used to lookup items based on the keywords that a user enters. I mentioned that there’s a lot of variation between NetSuite instances, both in terms of how they’re configured and customized. That makes NetSuite development both challenging and interesting.

As a result of the variation between NetSuite instances, you may need to modify the SuiteQL query based on how your NetSuite instance is configured. In the Xojo project, you’ll find that the query is stored as a constant named “SuiteQLQuery,” and it’s an attribute of the ListView screen.

The query uses the REGEXP_LIKE condition, which I discussed recently in this blog post. If you’re not already familiar with REGEXP_LIKE, then you might want to read up on it. Also, in the query I’m using the TO_CHAR function to format the “first column Base Price” as currency. Specifically, in the query, you’ll see this: TO_CHAR ( COALESCE( MAX( Price ), 0 ), ‘fmL99G999D00’ ). If you’d like to learn more about the TO_CHAR function and the format model modifiers that it supports, visit: https://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements004.htm#SQLRF00216

Our Next Webinar

Our next Xojo / NetSuite webinar will be held on Thursday, February 22nd at 1PM CT (US). I’ll demonstrate how you can use Xojo to develop a Web app that integrates with NetSuite. To signup, please visit Xojo’s Webinar page. And finally, I want to thank everyone that attended the webinar, as well as Geoff and the entire Xojo team for the opportunity to present.

Tim Dietrich develops custom software for businesses that are running on NetSuite. He makes extensive use of Xojo to develop mobile, desktop, Web apps, and more – all of which integrate seamlessly with NetSuite. To learn more, visit: https://timdietrich.me

This blog post is intended as a follow-up to that webinar. In it, I hope to provide some additional information that we didn’t have time to cover, answer some of the questions that came up during and after the webinar, and also provide a link to the Xojo project that we created during the webinar.

Downloading the Xojo Project

The Xojo project that we developed during the webinar is available for download here. In the zip file, you’ll find the project and a “Readme” file that includes instructions on how to set things up (including SuiteTalk REST, a custom NetSuite role, an integration record, etc).

My advice is to download the project, setup NetSuite, and run the project. Then look at how the project was built -the screens, methods, and so on. After you’re familiar with the project file, experiment with it. Perhaps try modifying the project so that instead of providing access to Items it provides access to Employees instead.

If you run into any problems, or have questions, please feel free to email me (timdietrich@me.com). Another great resource for your general Xojo questions is the Xojo Programming Forum.

Have fun!

Questions & Answers

Do you prefer to use RESTlets instead of SuiteTalk REST? If so, why?

Yes, I much prefer using RESTlets in all of my NetSuite integration projects. With RESTlets I have more control over the functionality that the API provides, and more control over how the responses are formatted. Also, my experience has been that RESTlets are slightly faster than SuiteTalk REST.

That being said, SuiteTalk REST does have some advantages over RESTlets. For example, SuiteTalk REST provides endpoints that you can use to get metadata, which is something that is often difficult to do with a RESTlet. But perhaps the biggest advantage of SuiteTalk REST is that, unlike RESTlets, there is nothing extra that needs to be installed in your NetSuite account. It’s simply a matter of enabling it.

You mentioned some NetSuite customer statistics in your presentation. Can you repeat those?

Sure. During his SuiteWorld keynote presentation this year, Gary Wiessinger (SVP of NetSuite Application Development) mentioned NetSuite’s growth in terms of the number of customers that are using NetSuite. So as of October 2023, 37,000 customers are using NetSuite, and that represents 324,000 organizations. And those customers are located in 219 countries and territories.

As a Xojo developer, how can I get started with NetSuite?

You should first try to get access to a NetSuite account that you can experiment with. Unfortunately, that’s not as easy as it is with other platforms (such as Salesforce or ServiceNow), where they provide developers with test accounts. My advice would be to reach out to a local NetSuite partner, and see if you can build a relationship with them, and try to get their help in getting started.

After the demo, you mentioned another Xojo project that extends the Android functionality. What was that?

It’s called Android Design Extensions, and there’s a great blog post about it here. Read multiple posts about Android Design Extensions on the Xojo Blog.

Wrapping Up

Thanks again for your interest in Xojo and in using it to develop apps that integrate with NetSuite. I hope you’ve found the webinar and the Xojo project to be helpful.

Happy holidays!

Tim Dietrich develops custom software for businesses that are running on NetSuite. He makes extensive use of Xojo to develop mobile, desktop, Web apps, and more – all of which integrate seamlessly with NetSuite. To learn more, visit: https://timdietrich.me

To use Barcode, you can just drag one onto your screen. Add the ScanCompleted event handler, which is called when a code is successfully scanned. You’ll get the result as a string parameter.

Call the Scan method on the screen object. For example, if you’ve dragged a Barcode class onto your screen and named it Scanner you can start scanning like this:

Scanner.StartScan

That opens the system UI for code scanning, activating the camera. When a code is successfully identified and scanned, Scanner’s ScanCompleted event is called with the value provided as a string.

You can then display this value or use it in some way. For example, you could detect if it is a URL and use it with an HTMLViewer.

Here is a sample QR code that has encoded “https://www.xojo.com”. Scan it to see the URL in the TextArea using this Barcode sample project.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Adding New Locations

Previously, the only way to add new locations to a MobileMapViewer on iOS was via code. Starting with Xojo 2023r4, the user can do this with a long press on the Map control itself. This will raise the new Pressed event handler providing the latitude and longitude parameters and allowing you to use these values to add a new MapLocation instance from the values; for example:

Var nl As New MapLocation( latitude, longitude )
MapViewer1.AddLocation nl

In addition, the user can now select any of the Pins previously added to the Map control and drag them to a new destination in the map.

Points of Interest

Another new feature for your Map-based iOS apps is the PointsOfInterest method for the MapLocation class. When this method is called on a MapLocation instance it will return an array of strings with the points of interest that are nearby. For example, relevant landscapes, monuments, museums, etc., just the kind of information the user may be interested in when walking around or when selecting any of the Pins in your app.

This line of code will retrieve points of interest (if any) from a MapLocation instance pointed by the “nl” variable:

Var pois() As String = nl.PointsOfInterest

Track the Distance

Another new method added to the MapLocation class on iOS is DistanceTo. This method is called on a MapLocation instance, expect to receive another MapLocation instance as the parameter. It will return a double value representing the distance, in kilometers, between the locations.

For example, this code added to the Pressed event of the MobileMapViewer will add the distance between a new location where the user long presses on the Map and a previous location saved in a Screen object property:

Var nl As New MapLocation( latitude, longitude )
MapViewer1.AddLocation nl

If PreviousLocation <> Nil Then
  distanceLabel.Text = nl.DistanceTo(PreviousLocation).toString
End If

PreviousLocation = nl

In Summary

With these additions and improvements available in Xojo 2023r4 for MobileMapViewer and MobileLocation on iOS, we expect you will be able to provide even more power and flexibility to your Map-based iOS apps! We can’t wait to see what you do with these!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Highlights and New Features in Android Design Extensions 2.0.

Buttons can now have borders in different thicknesses and colors. Use the SetStrokeColorXC and SetStrokeWidthXC extension methods for this. You can also use the same properties for the Android MobileDateTimePicker. You can also set the color of the button when it is clicked: SetRippleColorXC .

The colors of sliders and progress bars can now be set dynamically via the extension methods  SetProgressBackgroundTintListXC and SetProgressTintListXC.

Would you like to display the top bar of an app, where the time and battery status are displayed, in a dark color instead of white? No problem. The MobileScreen method SetSystemBarsAppearanceXC will help you. The Android Design Extensions sample app shows you how to use it.

The background color of individual segments of a MobileSegmentedButton can now also be set dynamically with SetBackgroundColorAtXC.

MobileTabPanel now supports the display of badges. You can set the color, position, and number of a badge individually.

Would you like a little more for the MobileTextArea? With the SetTextFromHtmlXC method, you can output formatted HTML content in the MobileTextArea.

MobileTextFields also experience a push forward with the latest Android Design Extensions. You can now show a clear button or, if it is a password field, show and hide the password. The name of the helper here is SetEndIconModeXC. You can also set the border color and border thickness of text fields. SetBoxStrokeWidthXC, SetBoxStrokeColorXC, and SetBoxBackgroundColorXC are the methods to be used.

Feel free to take a look at the developer repository, create feature requests, and provide feedback on extending this extension library.

I’m happy to receive any voluntary financial support for the work I’ve done so far, which you are welcome to share here. You can download the project with many examples here.

Happy Coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

Although Xojo for Android does not yet have full dark mode support, things continue to head in that direction. Previously your app would adjust its UI for light/dark if the Support Dark Mode property was turned on in the Android Build Settings. Starting in Xojo 2023r3, Color.TextColor and Color.FillColor also adjust their values when run in light mode or dark mode, making it easier for your custom drawing to also adapt.

MobileTextField gets a couple new additions. The ReturnPressed event is now called when, as the name suggests, return is pressed. The AllowSpellChecking property is now also available for MobileTextField and MobileTextArea.

In the Shared Build Settings Inspector there is now a Destination property as there is with other platforms.

Many Android devices have physical back buttons and all let you turn on global software controls that have a back button, but sometimes you want to have the back button clearly shown on the navigation toolbar. With Xojo 2023r3, the new HasBackButton property of MobileScreen can show a back button on the navigation toolbar.

To make it easier to write code that is applicable to both iOS and Android, but not other platforms, there is a new TargetMobile constant available for conditional compilation.

MobilePopupMenu is an all-new control for Android that makes it possible to simplify some of your user interfaces. It works similarly to a PopupMenu on Desktop or Web: when the user taps this control a list of items appears and they can choose one.

On the Advanced tab of the Android Build Settings there is a new Manifest section with a Permissions property. Here you can specify the names of Android permission constants that are needed by Declares or libraries. They are added to the AndroidManifest.xml file when the app is run/built.

MobileHTMLViewer got several enhancements. It now has various processing events, including: DocumentBegin, DocumentComplete, CancelLoad, Error, NewWindow, DocumentProgressChanged and TitleChanged.

And there is now support for running JavaScript using the ExecuteJavaScript method along with the JavaScriptResult and JavaScriptRequest events. ExecuteJavaScript is asynchronous and results appear in the JavaScriptResult event. To call the JavaScriptRequest event, use xojo.execute() in the JavaScript code. A method name and up to 5 parameters can be passed back to Xojo. Learn more in the Xojo Programming Documentation.

The last thing I want to highlight is the new Kotlin Declare. For advanced users, this adds the ability to create Android declares that can pass untouched calls via Alias (with the exception of required type/object handling) to the Kotlin compilation step. This is done by specifying Lib “Kotlin” or adding “:Kotlin” to the end of Lib. Here are a couple examples of what this can look like:

Declare Function AndroidVersion Lib "Kotlin" Alias "android.os.Build.VERSION.RELEASE" As CString

Declare Sub findAllAsync Lib "Object:ctrl:MobileHTMLViewer:Kotlin" Alias "findAllAsync(myfind.toString())" (myFind As CString)

Of course there were many bug fixes as well. Be sure to check out the full release notes for all the details.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

As for any other features involving the MobileLocation control on iOS, the same rules apply when enabling the required capabilities (from the Attributes section in the Inspector Panel with the iOS item selected in the Navigator), and also when requesting the user’s permission to use location services. In fact, it is advisable to enable the Background Modes > Location capability so your app still gets notified both when using Visits or GeoFencing and the app itself is running in the background.

Because we want to receive these events even when the app is not in use, you will want to use the MobileLocationUsageTypes.Always value for the request:

location1.RequestUsageAuthorization(MobileLocation.UsageTypes.Always)

Have a Nice Visit!

From the device point of view (iPhone or iPad), Visits are the most power-consumption effective way to track the user location involving almost no code. The downside is that the operating system does not guarantee the immediate sending of the generated events to the running app.

In order to get this to work in your Xojo iOS app all you need to do is set the VisitAwareness property on the MobileLocation instance of the app to True. Setting the instance to True starts tracking the device location and setting it to False stops tracking and raising Visits based events in the app.

Then, when implementing the VisitChanged Event Handler in the MobileLocation instance of the app, it will receive the following parameters when a new Visit event is raised by the operating system:

• latitude As Double
• longitude As Double
• accuracy As Double
• arrival As DateTime
• departure As DateTime

So, for example, it will be really easy to automatically add new MapLocation instances to a MobileMap in the app based on the information received. The following snippet of code added to the VisitChanged event shows how to do that on a MobileMap control instance named VisitsMap that has been added to the Screen of the iOS app:

Var arrivalDate As String = If(arrival <> Nil, arrival.ToString, "")
Var departureDate As String = If(departure <> Nil, departure.ToString, "")

Var lc As New MapLocation(latitude, longitude, "Arrival: " + arrivalDate + EndOfLine + "Departure: " + departureDate)
VisitsMap.AddLocation(lc)

It is worth mentioning the checks on the arrival and departure DateTime objects against Nil, iOS does not guarantee to always fulfill this information on the generated Visit events. That means, you may just receive the arrival date and time or the departure date and time, or both of them.

Lastly, the Visits feature will not work when the app is run in the Simulator so you will need to build the app and copy it to the device itself (using Xcode > Devices and Simulators window). You can find an example project for the Visits feature in the Examples folder in the Xojo download,

The screenshot above shows what it looks like after using the app (in the background) for about one hour. As you can see, several MapLocation items have been added to the map tracking the places visited by the user.

GeoFencing on iOS

GeoFencing allows the operating system to notify the app when the device enters and/or exists a previously registered region. These regions are created by providing latitude, longitude and radius (in meters) values along with a String value that uniquely identifies the region. These regions persist even after exiting the app or restarting the device. The main limitation is that a maximum of 20 regions can be registered by an app.

The way to create such regions is through the new MobileCircularRegion class; for example:

Var EiffelTowerRegion As New MobileCircularRegion(48.858093, 2.294694, 20.0, "EiffelTowerExample")

By default it is set to notify when the device enters and leaves the region, this can be changed using the available class properties.

Once the region instance has been created, it needs to be added to the MobileLocation instance of your app using the AddRegion method:

MyLocationInstance.AddRegion(EiffelTowerRegion)

Lastly, and in order to receive GeoFencing events, add the RegionEntered and/or RegionExited Event Handlers to the MobileLocation instance in your app. Both of these will provide the associated MobileCircularRegion instance as the parameter, so the logic of your app can take the required path based on that.

Also, while the Visits feature can only be tested on a physical device, the GeoFencing feature can be tested in the Simulator.

You will also find other new methods in MobileLocation in order to remove a previously added Region or retrieve all the registered Regions in addition to adding them as we did in the earlier code example above.

As with the Visits, you can find a project in the Examples folder to test GeoFencing on iOS.

In Summary

Both Visits and GeoFencing provide to you new ways of retrieving the user location that can be more suitable for the purposes of the iOS apps you develop with Xojo, and because these are based in events managed by the operating system itself, they have less impact in the iPhone/iPad battery.

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

• Declares for the new MobilePopupMenu
• Declares for MobileMoviePlayer
• Extensions for all MobileUIControl subclasses
• New extensions for AndroidMobileTable
• New extensions for MobileScrollableArea
• New extensions for MobileSwitch
• New extensions for MobileTabPanel
• New extensions for MobileTextArea
• New extensions for MobileTextField

Use MobilePopupMenu to Display it in Other Controls

The new MobilePopupMenu is a nice new addition to Xojo’s Android control library. Wouldn’t it be nice to display the popup menu when clicking on a Button or Canvas as well? With the Android Design Extensions you can achieve this.

1. Create a new Android project
2. Import the Android Design Extension folder into your project
3. Add a MobilePopupMenu (PopupMenu1) from the library to Screen1
4. Add some entries to the PopupMenu1 in the Inspector in the InitialValue section (say “Apple”, “Banana”, “Peach”)
5. Set the Visible property of the PopupMenu1 to False
6. Add a MobileButton (Button1) from the library to Screen1 and place it over the “invisible” PopupMenu1
7. Add the Pressed-Event to Button1 with the following code:

Call PopupMenu1.PerformClickXC

8. Add the SelectionChanged-Event to the PopupMenu1 with the following code:

Button1.Caption = Me.SelectedRowText

9. Run your project by clicking Run.

You can use this technique with any control that you want to have a popup menu. For example, in a Canvas you would use the PointerDown-Event.

Feel free to take a look at the developer repository, create feature requests, and provide feedback on extending this extension library.

I’m happy to receive any voluntary financial support for the work I’ve done so far, which you are welcome to share here. You can download the project with many examples here.

Happy Coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

Locking Controls

For Android, we use control locking just like you are used to when building desktop and web apps in Xojo. Control locking has always worked quite well and in the odd case where it doesn’t do exactly what you want, it’s easy enough to write a line of code or two to get the control to behave exactly the way you wish.

Implicit Instances

You are likely familiar with using the name of a window or webpage in code to access it. When you do this, you are accessing an implicit instance. For Android, Xojo supports implicit instances.

TaskEditorScreen.UpdateControls(Me.SelectedRowText, complete)
TaskEditorScreen.Show

AndroidMobileTable

Tables are extremely common controls for mobile apps. Xojo provides the AndroidMobileTable control for this purpose. If you use Xojo’s desktop or web ListBox controls, you will be familiar with how to use the AndroidMobileTable control.

On-Device Debugging

While you can create an Emulator (the Android equivalent of the iOS Simulator), you will likely find that it is faster and easier to use an actual Android phone or tablet for on-device debugging. If you do not have an Android device, you can pick one up from Amazon for about $100USD to $150USD. Make sure it supports a recent version of AndroidOS. Read more about on-device debugging for Android in the Xojo Documentation.

The Back Button

Android has a system-provided Back button that is usually available at the bottom of the screen. so there’s no need for you to provide one in your app. If there is no back button a swipe from the left edge of the screen takes you back.

Of course there are other differences, but these are 5 of the big ones you’ll want to know about from day one of your Android app building adventure. More Xojo Blog posts demonstrating what you can do with Xojo Android.