I’m talking with a number of other individuals who will also be joining the MVP program shortly. These are in addition to all the fabulous MVPs already listed in the MVP directory. We are in the middle of a major overhaul of the MVP directory, after which all the above members should be reflected there.
When talking about Delphi XE5’s support for Android and iOS, someone usually asks if we plan to support Windows Phone, but never asks (that I’ve heard) if we plan to support Blackberry. In the news we keep hearing how Blackberry is struggling and losing market share, while Microsoft is fighting to gain market share. Interestingly Blackberry is still ahead of Microsoft.
Looking at ComScore’s latest numbers we see Blackberry has 4.3% while Microsoft has 3.0%. Both are still in decline over the long haul. So even if Microsoft captured Blackberry’s 4.3% and Symbian’s 0.3% they would still only be at 7.6% compared to Android’s 51.8% and Apple’s 40.4%.
Microsoft has a way to go before they become a serious contender, and any other smartphone OS will be fighting an uphill battle to gain a foothold. With Microsoft’s deep pockets they could ride out a much longer storm than any upstart in this space, so I expect they are the only one who could turn up as an actual 3rd alternative.
Very exciting to see an update from TMS for their TMS Pack for FireMonkey with support for XE5 and Android (as well as iOS, OS X and Windows). Their pack includes a great diverse collection of controls for both mobile and desktop apps.
Fragmentation is the term used to describe all the variations available on the Android platform. Android has many manufacturers and models, unlike iOS where there is only one manufacturer, and they only have 3 (or 4) different models: iPhone, iPod, iPad (and iPad Mini).
The Android Dashboard is a great resource for tracking the adoption of different versions of the Android OS. It is updated monthly and also covers screen sizes and densities and Open GL versions.
Another great resource is OpenSignal fragmentation report. It shows market share by model and manufacturer, as well as some different ways of looking at the information in the Android Dashboard, as well as screen size. It appears to be updated annually.
I didn’t realize Samsung had almost 50% of the Android market, and I expected HTC to have a larger share. No wonder Apple feels threatened by Samsung. Noticeably missing from their list is any Amazon Kindles or Barns and Noble Nooks. That could be because they do not access the Google Play Store by default. I didn’t see the method of data collection.
Fragmentation is a bit of a headache for the app developer because there are so many different variations to take into consideration. The flip side though, is the flexibility of Android has really lead to its mass adoption. It works in both the ultra high-end luxury devices as well as the low-end economy devices. So while it is difficult to get an app that works on all devices, you still have a lot of possibilities to choose from.
When you run it the first line tells you if you have an ARMv7, second line is Android OS version, and 3rd line is if you have NEON instruction support. Those are the dependencies of Delphi XE5 on Android. The rest of the lines are extra details for your information.
When you run it your output should look something like the following. If those three lines check out then your device is ready for Delphi XE5 development.
Unlike iOS, there are are a huge variety of Android devices. Delphi XE5 supports the large majority of those devices. The official page for Android Devices Supported for Application Development spells out the requirements of Gingerbread, Ice Cream Sandwich or Jelly Bean on an ARMv7 processor (with NEON instructions). The NEON instruction requirement excludes the TEGRA 2 processor which was apparently popular in some tablets (mostly) a few years back. Also excluded is the Intel Atom processor, which I hear is showing up in Android devices in Japan.
If you look at the Android Dashboard we see those versions of Android make up 87.5% of the Android devices accessing the Android store. What that doesn’t tell us is how many of those devices have ARMv7 with NEON instructions. The DocWiki page also includes a number of devices that were tested for various functions, but really in the grand scope of possible Android devices it is a rather small sample.
So I had the idea of using Apkudo. They provide an online service where you upload your Android app APK and they run it on a wide variety of devices and tell you how it did. Currently I’ve only done a “hello world” type app test, but it gives a good guide for devices that support XE5 at a minimum level.
They have 118 devices that run Android 2.3.3 (Gingerbread) or better (no Honeycomb). Our of those devices, my APK failed to install on 10 devices. Looking at the log it either timed out, or was out of storage space, so that may be more related to the state of the device before the test than any issues with the actual app. Out of the 108 devices that loaded and ran the app, it only failed (ANR = Application Not Responding) on 3.
Devices tested: 118
Failed to install: 10
Locked up: 3
Successfully ran: 105
Success rate: 89%
From what I hear it isn’t uncommon for an app to fail for no reason on some of these devices, due to other influences (like no storage space). So that rate may actually be higher. I’ve shared the full spreadsheet report here for you to look for your favorite devices. (They don’t provided a download of the report, so I had to transcribe it to the spreadsheet. There may be typos.)
I plan to modify some of our existing test apps and upload them. Since the test system just uses monkey it isn’t guaranteed to actually perform the specific actions of the test apps, so I need to automate that part of the app. When I do I will update that spreadsheet and provide an updated post.
I’m sure some people will point out that you could use Java and reached more devices. Instead of focusing on the small percentage of Android devices you are missing with Delphi XE5, I’d instead invite you to consider the millions of iOS devices you can target from the same code base. Including iOS 7!
With the release of Delphi XE5 I’ve made the source of the Mobile REST Client Demo available. This is a really super simple demo of the Mobile REST Client in XE5. It is designed to show up how you can consume a JSON REST Service and adapt it into a DataSet and then bind that to the UI. If you change the data source you will probably need to change the live binding.
I’ve changed the demo from the one I used in the video to consume an OData data source. OData is a new standard backed by Microsoft for sharing data over the web. You can think of it as SQL for the web. It is a combination of other technologies, including REST, AtomPub, and JSON. Sybase supports OData on all of their databases now, as does Microsoft and others.
The change was simply a matter of pointing it to the Northwind OData endpoint provided on Odata.org. The binding is setup to show the company name in the listview. I added the ability to specify a Root Element, but that isn’t necessary for the demo.
This new technology works in both desktop and mobile, FireMonkey and VCL. It should also work in C++ Builder.
The Android emulator is impossibly slow when running inside a virtual machine. It is possible to debug against a remote emulator via SSH. Here are the steps to connect from a Windows guest OS to an OS X host OS (they can be easily adapted for a Windows host). It does require installing the Android SDK on the host OS and creating and running an emulator there. It seems to work even if you have a device connected too. I’ve gotten them both to show up in the IDE and am able to pick between them and deploy and run on the emulator. The Emulator is still slower than hardware, but this makes it usable.
Of note, this emulator performance isn’t an issue with Delphi, but is an issue with the Android emulator. So you may find this tip useful with other Android development tools as well.
This could be adapted to debug against a remote Android Emulator running on a remote machine located anywhere on the internet. Just requires port 22 to be open between the two machines.
Install the Android SDK (not the ADT bundle) on your Mac OS X host & start an ARM based emulator (With use Host GPU enabled)
Enable SSH on the host
On a Mac OS X Host go to System Preferences -> Sharing -> Remote Login
On a Windows host, you need to install a 3rd party SSH host. FreeSSHd has been found to work.
Install the PuTTY SSH (putty.exe) client on the Windows Guest OS
Ensure port 22 is open between the Windows guest OS and the Mac OS X host.
Create a connection in PuTTY to the Host OS
You will most likely use the 192.168.x.x IP address of the host
Go to Connection -> SSH -> Tunnels and add a local/auto port forwarding for 5555 to locahost:5555 and 5554 to localhost:5554.
Save and Open the connection in PuTTY
Provide the login credentials for the Mac OS X host – anything typed in this window is executed on the remote machine
You can check or change the tunnel settings via the icon in the upper left of the PuTTY window
Minimize PuTTY (keep it open to maintain the SSH connection)
Open a new command window in the Windows guest OS and type “adb kill-server & adb devices” and you should see the emulator-5554 as a listed device.
Refresh target devices in Delphi and it should appear
This should work for any emulators or devices connected to the remote machine. Unlike emulators that are local, you need to start the emulators before Delphi will see them. You may need to adjust the tunnel port numbers if you are connecting multiple devices.
Delphi MVP and my friend Simon Stuart just updated his MonkeyMixer utility for XE5 (in addition to XE2, XE3 and XE4).
Once installed (and you’ll need to close the IDE before installing, by the way) you’ll be able to right-click on any VCL or FMX project in the Project Manager to toggle the project between VCL and FMX.
You do this by clicking Switch Project to FireMonkey or Switch Project to VCL(depending on what the project type is at that time).
Keep in mind mixing FireMonkey and VCL forms in the same application isn’t officially supported, but this is a good option for migrating a VCL application to FireMonkey, or just including exactly the features you need.