{"id":1503,"date":"2013-08-22T09:23:36","date_gmt":"2013-08-21T21:23:36","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=1503"},"modified":"2013-08-22T09:23:36","modified_gmt":"2013-08-21T21:23:36","slug":"sharing-code-across-platforms-in-oxygene","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/1503\/","title":{"rendered":"Sharing Code Across Platforms in Oxygene"},"content":{"rendered":"[Estimated Reading Time: <\/span> 5<\/span> minutes]<\/span><\/span>

There seems to be a perception among some people that Delphi is in the unique position of allowing developers to share and re-use code across the various platforms that it’s compiler can now (and will soon) target. But this is not the case. Oxygene<\/strong> has had this capability right from the start.<\/p>\n

<\/p>\n

To exercise this, at an admittedly rudimentary level so far, I created a simple application for iOS<\/em> using Oxygene Nougat<\/strong>. The application is very simple, consisting of two edit fields and a button. You enter two numbers into the fields, press the button and the application pops up a message with the sum of those two numbers.<\/p>\n

I then created the same application using Oxygene Cooper<\/strong>, for Android<\/em>.<\/p>\n

Clearly the amount of “business logic” involved is minimal. The vast majority of this simple application resides in the UI. But the object of this exercise was to explore the sharing of generic, non-platform-specific code between different Oxygene<\/strong> projects.<\/p>\n

First, here is my Adder<\/strong> class that will be shared across the platforms:<\/p>\n

\r\n\r\nnamespace Deltics.Adder;\r\n\r\ninterface\r\n\r\n  type\r\n    Adder = public class\r\n    public\r\n      property A: Integer;\r\n      property B: Integer;\r\n      property Sum: Integer read A + B;\r\n    end;\r\n\r\nimplementation\r\n\r\nend.\r\n<\/pre>\n
As I say, this is hardly rocket science.  But something worth pointing out here is the efficiency of the Oxygene<\/strong> syntax.<\/p>\n
First, to declare a read-write<\/em> property, such as the A<\/strong> and B<\/strong> properties in this case, you do not need to erect the backing field and specify the read\/write accessors.  Simply declare the property and the type.  You can of course specify read-only<\/em> properties, and we have one here also which demonstrates another efficiency.<\/p>\n
The Sum<\/strong> property is a read-only<\/em> property which returns the result of the addition of the A<\/strong> and B<\/strong> properties.  Such relationships can be expressed directly with read expressions<\/em>.  There is no need to implement a separate property read accessor method.<\/p>\n
The other thing to note is that “units” in Oxygene<\/em> are declared as members of a namespace<\/strong>.  i.e. rather than namespaces being fabricated from arbitrarily unique unit names, they are a formal part of the language.  There is no need for each unit to have a unique “unit name” – the filename distinguishes them as separate files after all.<\/p>\n
Just for a fun comparison, here’s the equivalent Delphi<\/strong> class:<\/p>\n
\r\n\r\nunit Deltics.Adder;\r\n\r\ninterface\r\n\r\n  type\r\n    TAdder = class\r\n    private\r\n      fA: Integer;\r\n      fB: Integer;\r\n      function get_Sum: Integer;\r\n    public\r\n      property A: Integer read fA write fA;\r\n      property B: Integer read fA write fA;\r\n      property Sum: Integer read get_Sum;\r\n    end;\r\n\r\nimplementation\r\n\r\n  function TAdder.get_Sum: Integer;\r\n  begin\r\n    result := fA + fB;\r\n  end;\r\n\r\nend.\r\n<\/pre>\n
Just as Oxygene is a “better C#”, it’s also a “better Delphi”.  imho.  \ud83d\ude42<\/p>\n
But back to Oxygene.<\/p>\n
I won’t bother you with the details of the applications themselves.  Suffice to say that in each case I constructed the UI programmatically, as an exercise primarily in forcing myself to actually write some platform code as a learning exercise.  But it should be noted that despite perceptions to the contrary in some quarters, Oxygene<\/strong> does<\/em> have GUI building tools.  Or rather, it works alongside the existing GUI building tools provided for each platform.<\/p>\n
Did somebody say “native” ?<\/p>\n
But I digress.  Again.  \ud83d\ude42<\/p>\n
In terms of solution structure (something that I expect to evolve as I gain experience with multiple platforms and Visual Studio<\/em> solution concepts in general) I arrived at the following on disk:<\/p>\n
\r\n   Adder                    [Solution folder]\r\n      Deltics.Adder.pas\r\n      iAdder                [iOS project folder]\r\n      org.me.adder          [Android project folder]\r\n<\/pre>\n
The Deltics.Adder<\/strong> unit (I think it is correct to still call it a unit even though the code is not part of a formal unit declaration as such) is added to each of the iAdder<\/strong> and org.me.adder<\/strong> projects using “Add Link” (i.e. reference) so that each project references this common file rather than having separate copies (which irritatingly is the default behaviour in Visual Studio<\/em> when adding an existing file to a project).<\/p>\n
So, now to those projects.  Here is the code from the iOS<\/em> GUI that employs my simple Adder<\/strong> class:<\/p>\n
\r\nmethod RootViewController.btnSumPressed;\r\nvar\r\n  adder: Adder;\r\n  msg: UIAlertView;\r\nbegin\r\n  adder := new Adder;\r\n\r\n  adder.A := textA.text.integerValue;\r\n  adder.B := textB.text.integerValue;\r\n\r\n  \/\/ Initialise our Alert View Window with options\r\n  msg := UIAlertView.alloc.initWithTitle('The Sum of the Parts is...')\r\n                           message(adder.Sum.stringValue)\r\n                           delegate(self)\r\n                           cancelButtonTitle('OK')\r\n                           otherButtonTitles(NIL);\r\n                           \r\n  msg.show;\r\nend;\r\n<\/pre>\n
And here is the equivalent code from the Android GUI:<\/p>\n
\r\nmethod MainActivity.ButtonOnClick(v: View);\r\nvar\r\n  myAdder: Adder;\r\n  msg: AlertDialog;\r\nbegin\r\n  myAdder := new Adder;\r\n  myAdder.A := Integer.parseInt(textA.Text.toString);\r\n  myAdder.B := Integer.parseInt(textB.Text.toString);\r\n\r\n  msg := new AlertDialog.Builder(self).create;\r\n  msg.Title   := 'The Sum of the Parts is...';\r\n  msg.Message := myAdder.Sum.toString;\r\n  msg.show();\r\nend;\r\n<\/pre>\n
Now I should mention that the AlertDialog<\/strong> code here is incomplete.  As written above it currently presents a dialog with no buttons, meaning that I have to use the Android<\/em> “back” hardware key to dismiss it, but the point of this post is the sharing of code between platforms not the platform UI concerns that I am still learning (I have to say that so far iOS<\/em> has been the more pleasant experience, by far).<\/p>\n
Of course this does raise the interesting point that on iOS<\/em> there is no hardware “back button” which in turn raises the question, just how exactly does anyone think they can realistically create one app from one set of source that will behave properly<\/em> on different platforms that themselves work differently<\/em> ?<\/p>\n
This is of course why I chose Oxygene<\/em>.  Yes, it is an inconvenience having to create platform specific GUI’s.  But it is also in my view necessary<\/em>, and to think otherwise is frankly delusional.<\/p>\n
But back to the issue of the day.<\/p>\n
Let us compare the usage of the shared “business object”.  First, the setting of the A<\/strong> and B<\/strong> properties:<\/p>\n
\r\n  \/\/ Nougat - iOS\r\n  adder.A := textA.text.integerValue;\r\n  adder.B := textB.text.integerValue;\r\n\r\n  \/\/ Cooper - Android\r\n  myAdder.A := Integer.parseInt(textA.Text.toString);\r\n  myAdder.B := Integer.parseInt(textB.Text.toString);\r\n<\/pre>\n
This illustrates some pretty fundamental platform differences between iOS<\/em> and Android<\/em>, each requiring different incantations to obtain an integer from the corresponding string representation.  In the case of iOS\/Cocoa<\/em>, the string<\/strong> type itself has a method to achieve this – integerValue<\/strong>.  In the case of Android\/Java<\/em>, we use the parseInt<\/strong> method of the Integer<\/em> type.<\/p>\n
Of perhaps more interest is what happens when we are working with the Sum<\/strong> property, to obtain the string representation of its integer value:<\/p>\n
\r\n  \/\/ Nougat - iOS\r\n  message(adder.Sum.stringValue)\r\n\r\n  \/\/ Cooper - Android\r\n  msg.Message := myAdder.Sum.toString;\r\n<\/pre>\n
Here we something very strange.  In each case, we are working with a string<\/strong> type property of a class which was not written specifically for any particular platform.  Yet in each case the mechanism for obtaining the string representation of that integer is different and each appears to be a method of the string<\/strong> type itself.<\/p>\n
How can the same string type have different methods ?  And if it is the same type, why can we not use the same method in each case ?<\/p>\n
The answer of course is that it is not the same type at all.  Both Android<\/em> and iOS<\/em> have types which correspond to a “String” type, and Oxygene<\/strong> maps these onto our property type.  It is a String but when required it is an NSString<\/strong> or a java.lang.String<\/strong>.<\/p>\n
Although the mechanism involved is different, this effect is essentially the same as the approach in Delphi<\/strong> taken with the String<\/strong> type, where even with all of the additional RTTI that makes String<\/strong> so useful in Delphi<\/strong>, it is also a pointer to a simple null terminated string (PChar<\/strong>) that can be used directly (in most cases) with the platform API – i.e. Win32<\/strong>.<\/p>\n
The Spirit of Delphi<\/em> lives on.  Just these days, not in Delphi itself.<\/p>\n
Something else that is going on that is less obvious is that when compiled for Android<\/em>, my Adder<\/strong> class extends the Java<\/em> Object<\/strong> class.  When compiled for iOS<\/em> the same class extends the Cocoa<\/em> NSObject<\/strong>.<\/p>\n
Did someone say “native” ?  \ud83d\ude09<\/p>\n
At this point I should apologise to anyone at RemObjects<\/strong> if my understanding of what is going on is not accurate.<\/p>\n
Some people will be aghast at the implications of this.  This means after all that when you are writing the code for a business object that will be shared across different platforms you must be careful to avoid any platform specific incantations in that code.  That could be difficult when even such things as simple as converting between string and integer representations are platform specific operations.<\/p>\n
This is where Sugar<\/strong> comes in, and where the concept of “mapped types” in Oxygene<\/strong> comes to our aid.<\/p>\n
That will be the feature in my next post on Oxygene<\/strong>.<\/p>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span> 5<\/span> minutes]<\/span><\/span> There seems to be a perception among some people that Delphi is in the unique position of allowing developers to share and re-use code across the various platforms that it’s compiler can now (and will soon) target. But this is not the case. Oxygene has had this capability right from the start.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":[]},"categories":[205,4,204,180],"tags":[153,94,137,181],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-of","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":1199,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1199\/","url_meta":{"origin":1503,"position":0},"title":"Oxygene “Nougat” is Mac and iOS !","date":"06 Sep 2012","format":false,"excerpt":"Marc Hoffman has confirmed that \"Nougat\" is to Mac\/iOS as \"Cooper\" was to Java. \u00a0Some have speculated that this will be based on Mono, but Oxygene has had Mono covered for some time already, so I strongly doubt that this is the case. Far more likely is that just as\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":2416,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/2416\/","url_meta":{"origin":1503,"position":1},"title":"Relight My Fire","date":"01 May 2016","format":false,"excerpt":"I'm not sure how many more song inspired Fire references I can keep coming up with, but here at least is one more. In response to my previous post Wouter commented that he had a much simpler cross platform solution to the random number problem: Which is very pithy but\u2026","rel":"","context":"In "Cooper"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1624,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1624\/","url_meta":{"origin":1503,"position":2},"title":"Exploring Listeners With Oxygene","date":"16 Sep 2013","format":false,"excerpt":"Part 2 in a short series demonstrating the development of a simple camera app for Android using Oxygene. In the previous instalment we looked at the basic framework of our app. For this instalment I was going to show how to implement the camera preview or viewfinder for this instalment,\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1713,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1713\/","url_meta":{"origin":1503,"position":3},"title":"How to Call Java Code from an Oxygene Android Application","date":"20 Sep 2013","format":false,"excerpt":"Lachlan just posted a link to a post on Google+ (also available as a PDF) demonstrating how to call Java from Delphi XE5. I was shocked at both the amount and the nature of the code involved. It is long, convoluted and ugly stuff (nb. that isn't a criticism of\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":2280,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/2280\/","url_meta":{"origin":1503,"position":4},"title":"Oxygene Constructor Magic on Cocoa","date":"30 Aug 2014","format":false,"excerpt":"Earlier this week I mentioned that I had published my TXT-2-PARK app for Android in the Google Play Store. Today I published the iOS version to the Apple App Store (still awaiting approval at this stage). As with the Android version, I implemented the iOS version using Oxygene, and things\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1457,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1457\/","url_meta":{"origin":1503,"position":5},"title":"Learning Cocoa with Oxygene and Objective-C","date":"11 Aug 2013","format":false,"excerpt":"When XE4 came out and the full extent of the bait and switch perpetrated by Embarcadero became clear, I decided that my money was better spent with RemObjects and their Oxygene product. But it has only been this past weekend that I finally found some \"quality time\" to spend with\u2026","rel":"","context":"In "Delphi"","img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/Screen-Shot-2013-08-11-at-17.39.14-.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1503"}],"collection":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/comments?post=1503"}],"version-history":[{"count":4,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1503\/revisions"}],"predecessor-version":[{"id":1507,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1503\/revisions\/1507"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=1503"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=1503"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=1503"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}