Compliance with the Apple's App store policies:

texturegainfulΚινητά – Ασύρματες Τεχνολογίες

10 Δεκ 2013 (πριν από 3 χρόνια και 8 μήνες)

65 εμφανίσεις

With DYNApp you can create

native Titanium applications

which can be downloaded to the
device and updated in real time, just like web pages, but, unlike web pages, these apps are
native Titanium apps and can use every feature of the Titanium SDK, just
like this:



dynapp.createWindow({





url: 'http://www.myserver.com/my_source_code.js',





ready: function(win) {







win.open();




},





error: function() {







alert('Ooops, looks like the Internet connection is down...');




}

});


Dream? Not An
ymore!


Here are some benefits of DYNApp:





More than 10x productivity gain:

You will have 10 times+ productivity boost, since you don't have to re
-
install your app on the
device every time you made a change, just update your source code on your server,
and
restart or refresh your app on the device!



Drastically simplified distribution of your apps:

You can show your project's progress to your customers all the time, without the need to send
them new installations: just create a "staging" copy of the code
on your server which
customer's installation will be accessing. What about making a changes right there during a
phone discussion, so the customer immediately see them?



Instant updates and bug fixes:

You can instantly apply fixes to, or update

your code
across all installations, without the need
to distribute the new version of the app.


Compliance with the Apple's App store policies:



We're not suggesting to submit your app into the App Store with DYNApp being enabled. In
case if you're developing for t
he Apple's App Store, you can just copy your js files into the proper
place
-

Resource folder, and replace all DYNApp urls to point to these places. The best approach is to
have a global function for returning URLs which would understand "production" flag
of some sort and
would replace all URLs to local refs when you compile for submission.


Android Market does not have such a drastic requirements as Apple does (at this time, anyway), and
it's getting much bigger than iOS market. DYNApp would save your day
if you're developing for
Android, because you may have different files uploaded to the different types of devices, and also may
fix some un
-
expected problems with the newest updates and new types of devices.


If you're a commercial developer and develop fo
r clients, bypassing app stores all together
-

than
dynapp is a Godsend, as you can imagine.

For this type of development it's hard to imagine to do it any other way: instant bug fixes and new
releases across the whole install base, rapid and frequent prot
otyping, greatly simplified code
maintenance, etc.


So, we're not inviting you to play against rules, we just give you a tool to be more productive and,
possibly, more successfull!



DYNApp works on both iOS and Android platforms.


When developing with
DYNApp, probably 100% of your main app.js code will look exactly
like the following snippet:



var dp = require('com.infinery.dynapp');

var appUrl = 'http://
<your initial page's url goes here>
?tmp=' +
Ti.Platform.createUUID();


if (Ti.Platform.osname != 'a
ndroid') {


var win = dp.createWindow({


backgroundColor: 'white',


url: appUrl,


ready: function(w) {


w.open();


}, error: function() {
<notify the user about the internet connection
being down>

}


});

}

else {


var win = Titanium.UI.createWindow();




dp.Include(appUrl);




win.open(); Ti.include('./all_apis/apis.js');

}


This is the only code you will compile using Titanium Studio, and the only code you will
have to upload to the device by Titanium Studio.

This code assumes that you've already installed DYNApp Titanium module, and referenced it
in the app's Tiapp.xml file:


<modules>









<module platform="android" version="1.0">com.infinery.dynapp</module>









<module platform="iphone" version="1.0">
com.infinery.dynapp</module>

</modules>



You install this code on the device only once, and never go to the Studio again,
nor install your app to the device again, for the life of your project (
unless, of
course, you decided to use some Titanium modules l
ater on; those need to be installed by
the Studio
), because the rest of the coding will happen in your favorite editor by
editing pages on your server and just re
-
executing your app on devices. And
for tracing/debugging you'd use Cloudebug (
Studio's debugg
er is useless on the
actual device running actual, not debugging, code and when your device is not hard
-
wired
to your development workstation
).


Needless to say how much time just this simple fact will save you!


We developed DYNApp partially for a simple
reason that waiting 5 minutes after each little
change is made before we can even see it on the iOS device (Android is much more
acceptable in that sense) was driving us insane!!!







Explanation of the code:





appUrl variable contains the full url

of the starting page of your app, for instance
"http://www.server.com/mynewapp/mainpage.js";



we recommend using .js extension for your pages, but it can be any page which you
can open in browser, i.e. .html, .aspx, .php, etc;



the query parameter:

...?tmp
=' + Ti.Platform.createUUID()

prevents your pages from being cached by the operating system's handling of the
http protocol. Both iOS and Android do cache the pages, so
-

make sure you use this
parameter to prevent that;



iOS version of the dynapp module im
plements createWindow method to open your
page. This method is asynchronous and implements "ready" and "error" callbacks.

The "ready" callback receive 1 parameter
-

variable containing the normal
Ti.UI.Window object which is created by the DYNApp and refer
ences your page's
javascript.

You need to open this window, as usual: w.open() (of course, all Ti.UI.Window
features are supported, including animations, so you can open the window with
animation if you wish);



Due to the bug in Titanium SDK (which is being

fixed, but not fixed yet), the Android
version of the DYNApp module does not have createWindow method, but implements
"Include" method instead.

Include takes one parameter
-

url of your page, in the same exact form as iOS
version does.

Unlike createWindow
, Include method is synchronous, just like Ti.include.

So, for Android deployment, this snippet creates Ti.UI.Window object, than Includes
your script coming from your page, and opens the Window.


Effect of this code is exactly the same as in iOS's createW
indow, so the code of your
page can be is exactly the same for both platforms.



The include statement in Android section of the code:

Ti.include('./all_apis/apis.js');

is needed due to the bug in Titanium SDK, which prevents your DYNApp
-
based app
from using

any SDK function.

This include is a work
-
around and does the trick
-

your can use any feature of the
Titanium SDK in both iOS and Android versions!


Code strong!