Escolar Documentos
Profissional Documentos
Cultura Documentos
Cloud computing is new technology that has been widely studied in recent years. There
are numerous cloud platforms available in the market today. With the increase in the
number of cloud platforms in IT industry, the issue of understanding and using these
platform has risen steeply. We have tried to cover Appery.io and Meteor, two very
famous platforms for mobile app development. A detailed comparison has been
presented in this paper which is focussed on the aspects such as the architecture,
characteristics, applications, and user friendliness. We have tried to implement two
applications that use Google APIs to communicate with cloud platform and in turn, build
geolocation based application. Before conclusion, we have tried to demonstrate some
convergences and differences between Appery.io and Meteor platforms.
Introduction:
Cloud computing is a buzz word and is applied to several embryonic trends in the field
of information technology. The term computing in cloud implies to some of the
ubiquitous on-demand IT resources available on the internet. Nowadays every new
internet based service is labelled as cloud either officially or externally. Recently cloud
computing has garnered a notable amount of interest and with this; there has been a
growing ambiguity about the term "computing" in cloud paradigm too.
The need for a very clear and unambiguous terminology in cloud computing is felt today
[1] [2].The currently available offerings in cloud computing are not properly standardized
mainly due to the relative infancy of the industry. Thus, neither the service providers nor
the actual consumers know what an "integrated" and "robust cloud computing service
should look like. Due to humongous features, a variety of services and vivid
implementations, cloud services are not easily comparable.
The scopes of various cloud computing product offerings overlaps and differ in many
labyrinthical ways. So there are multiple approaches and ongoing debates about cloud
computing [5] [6]. The goal of this paper is to perform a detailed comparison between
two cloud platforms (Appery.io and Meteor) and clarify the similarities and differences
alongside implementing a geo-location based mobile application. Clarifying the
relationship of technologies used with cloud computing and constraints of cloud
computing while developing a geo-location based mobile applications.
There are two major questions which are normally raised on the implementation of any
application based on the cloud.
1) How the application was implemented
2) What challenges were faced during the implementation of the application?
We targeted cloud computing for mobile applications so the first question about its
implementation can be fragmented in two aspects, one where to build the application
and second how the application will talk to the cloud. So in a whole main objective of the
paper is:
1. To discuss how to implement a mobile application that works with cloud platform as
its base.
2. How to make mobile application built with cloud platform accessible to different
operating systems on mobile phones.
3. What are the major challenges in the implementation of a mobile application based
on the cloud platform?
First, we are going to build a Geo-location based application in Meteor and then in
Appery.io.
Introduction:
Meteor or Meteor JS is a free and open source web framework based on Javascript
which is written using Node.js [9]. Meteor supports rapid prot0yping and can produce
cross-platform code. It collaborates with MongoDB and uses Distributed Data Protocol
and a publish-subscribe pattern to dynamically propagate changes in data to the client.
This dynamic change in data is done automatically by Meteor without requiring the
developer to write any type of synchronization code.
Meteor Architecture:
The above figure [8] shows the architecture of Meteor platform. The main functional
parts of this architecture are as follows:
EJSON: It is an extension of JSON. This imparts support to most data types like date,
Binary and some user defined types too. An example is of Mongo.ObjectID which is
supported by EJSON but not by JSON.
DDP (distributed Data Protocol): It is also referred as Meteors backbone. It is a
communication protocol based on JSON which serves as a link between the client and
the server. This allows Remote procedure calls to execute on Meteor server. This is
quite interesting as it allows non-native Meteor apps to talk to Meteor servers. In other
works, the application is speaking DDP and Meteor server can understand DDP.
MongoDB: Meteor uses Mongo databases for storing and retrieving data. MongoDB is
a cross-platform document-oriented database which is very suitable for JSON
documents.
Meteor Run: The core of Meteor application lies in its robust Javascript library packages
like underscore, HTTP and much more.
Cordova: Javascript library that provides user interface support to the Meteor to run
various mobile platforms.
Implementation:
Meteor is a platform that has been built for building the real-time application. and easy
mobile application with Cordova. So we are going to utilize Meteor as a platform to build
a mobile application.
Libraries used:
Leaflet
The leaflet is an open source Javascript library which can be used for mobile-friendly
interactive maps. It works perfectly across major desktop and mobile platforms. It can
be extended with lots of plugins too.
Underscore provides useful functions for programming. we specifically used the map
function to iterate values into arrays.
Ratchet.
This library provides a modular structure for CSS and scripts for Meteor platform
HTTP request
Cordova.
Goal:
The prominent goal of this application is to use Meteor libraries and mongo DB to
create geo-based urban location mobile application. We will use users locations and
then use Google APIs to make some logical decisions. The information from Googles
APIs would be poured into the database and then suggestions would be shown to a
user on his screen. This application keeps the track of user's location and shows him
nearby food locations. The application also tells if the food place is open or closed,
working hours and type of cuisine served in the food place.
I already have my Meteor application named city_app and the directory structure is as
follows:
Public- Code that can run in either client or server environment is placed here
Client- Code that runs on client side
Server- code that runs on server side.(secure code)
Collections- services that we want to use sit here.
Lib- This is the first directory that gets loaded while running the application
.Meteor- automatically provided by Meteor for quick development of the application.
[The libraries, I have created over here are standard libraries and in accordance with
Meteor structure.]
By default Meteor creates city_app.js and city_app.html file that helps in quick
starting of the project.
Installing packages needed for the project:
Atmospherejs.com is the best place to download Javascript packages. It provides
almost most of the packages available for the Meteor.
1)
iron:router :
Ratchet:
3)
Cordova.js (pugins.cordova.io)
Step 3:
Preparing client view:
Files: layout.html
Meteor uses <template> to handle HTML files. The same template may occur
multiple times on a page and these occurrences are known as template instances.
Meteor instances are put into documents and destroyed automatically by Meteor.
The use of Leaflet code package can be seen in layout.html. This code helps in
using CSS facility offered by leaflet.
The name of template that will be rendered first by our application is appLayout.
{{> header}} // iron router code to retrieve header view
{{> yield}} // code to render
{{> yield "footer"}} iron router code to retrieve footer
Iron router basically derives its code structure from ruby on rails.
Step 4:
Configuring the application to work on various mobile platforms using cordova
Meteor.startup(function() {
navigator.geolocation.getCurrentPosition(success); // function call for currentlocation
});
success = function(position) {
Session.set('location', position); // function with return call and location details
Meteor.call('fetchNearbyLocations', position.coords)
}
We make a call to get current location from users browser .This call returns back with
the position coordinates of the user. This location is used while taking any decisions in
the application. Then we use session which is more related to User interface and cant
survive a page reload. This session value is just used for the temporary purpose.
Persistent sessions can be used by session amplify facility. Session sets our location
and position as an object for us.
Step 5:
Places.js
We will make our database and values from the Google Maps in our database.
We have used ROBOMONGO software that allows connecting to local mongo
databases
Places = new Mongo.Collection('places');
Meteor.methods ({
'fetchNearbyLocations': function(coords) {
if (Meteor.isServer) {
results
=
HTTP.get("https://maps.googleapis.com/maps/api/place/nearbysearch/json?
location=" + coords.latitude + "," + coords.longitude&radius=500&types=food&
key=AIzaSy*********************")
console.log(results)
_(results.data.results).each(function(loc) {
_.extend(loc, {loc: {type: "Point", coordinates: [loc.geometry.location.lng,
loc.geometry.location.lat]}})
Places.upsert({id: loc.id}, {$set: loc})
});
}
}
});
First, we created a new mongo collection by the name places and used to store data
from Google Maps. The Meteor Methods are used to define new functions. We define
our core function fetchNearbyLocations to run on server side.
Hereby we make the call to the Google APIs to get locations. I like food so, I used
Googles Food API to get nearby food locations and provided my API key to complete
the call to API
https://maps.googleapis.com/maps/api/place/nearbysearch/json?location="
coords.latitude + "," + coords.longitude&radius=500&types=food&
Then every request returns with information about the nearby food places. This is
inserted in the database by loc.id.
Step 6:
Now we will move to server side implementation of the application.
Index.js
Places._ensureIndex({'loc.coordinates':'2dsphere'});
The server basically creates 2d index using location coordinates and loc.cordinates
would be created in database.
Publication.js
Meteor.publish('nearbyPlaces', function(bottomLeft, topRight) {
if (!bottomLeft && !topRight) {
return [];
}
return Places.find( { loc : { $geoWithin :{ $box : [bottomLeft, topRight]} }})
});
We use Meteor.publish over here and call our function nearbyPlaces. It returns the
geolocation with upper and lower index values.
Step 7:
Finalizing the client side to retrieve values from the session call
Template.home.rendered = function() {
Tracker.autorun(function() {
if (Session.get('location')) {
latitude = Session.get('location').coords.latitude;
longitude = Session.get('location').coords.longitude;
var map = L.map('map').setView([latitude, longitude], 15);
L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {
attribution: '© <a href="http://osm.org/copyright">OpenStreetMap</a>
contributors'
}).addTo(map);
bounds = map.getBounds();
if (bounds) {
Session.set('bottomLeft', [bounds._southWest.lng, bounds._southWest.lat]);
Session.set('topRight', [bounds._northEast.lng, bounds._northEast.lat]);
}
if (Template.instance().data) {
Template.instance().data.forEach(function(place) {
L.marker([place.geometry.location.lat, place.geometry.location.lng]).addTo(map)
.bindPopup("<strong>" + place.name + "</strong><br />" + place.vicinity);
});
}
map.on('moveend', function(event) {
bounds = event.target.getBounds()
Session.set('bottomLeft', [bounds._southWest.lng, bounds._southWest.lat]);
Session.set('topRight', [bounds._northEast.lng, bounds._northEast.lat]);
coords = {latitude: event.target.getCenter().lat, longitude:
event.target.getCenter().lng}
Session.set('location', {coords: coords})
Meteor.call('fetchNearbyLocations', coords)
});
}
});
}
We first set up client side to run the map on the screen with Tracker.autorun. The
latitude and longitude values are saved in variables.
Then we create map object and L. Map tells leaflet to map our object map and sets
view for the map object. 15 tells the zoom in the value of the map.
var map = L.map('map').setView([latitude, longitude], 15);
Leaflet cant provide tile feature to the application so we created our own tile feature.
The tile feature adds background information in the map.
Then we add marker to the current location of the user.
L.marker([place.geometry.location.lat, place.geometry.location.lng]).addTo(map)
.bindPopup("<strong>" + place.name + "</strong><br />" + place.vicinity);
We call map.getbounds() and gives us the required information in the form of latitudes.
This data is set and allows previewing, the nearby food places stored in the databases.
Implementation Success v/s Failures
1) The biggest issue with using Google APIs in Meteor is the call to Google Map API
itself. The call from the local host made to Google API is denied. The same call
works after deploying the application on cloud.
Application call on local host:
The same call to Googles API worked perfectly. So testing of application on local host
couldnt be completed.
Appery.io
1) Introduction
Appery.io is the first rapid development, integration and deployment platform for
delivering cross device apps in the enterprise. Appery.io is 100 percent cloud-based
since there is nothing to install or maintain and you can develop apps from
anywhere.
Appery.io is a cloud-based platform with visual builder and integrated backend
services. It is a powerful tool but what is underlying implementation when you create
the app? The resulting app has
HTML
JavaScript
CSS
jQuery Mobile
Any custom HTML, JavaScript, CSS added by the developer
Apache Cordova for native APIs and hybrid app creation
Any custom Apache Cordova plugins [1]
2) Platform Overview[6]
Under the hoods, its HTML, JavaScript, CSS and right now user use jquery mobile
for the components. Angular, bootstrap are the frameworks on which appear is
working currently. Now every app you create in appery.io bundles the Apache
Cordova or phone gap and allows us to package the app for the native platforms.
There are any third party plugins you can import them and you can use the API
Integrated Backend Services
Hosting Feature user can publish the HTML 5 mobile app to a custom URL or can
use them own domain.
Cloud Database
There is cloud database for storing app data. The user can send push notifications
to the users console the app. Server code allows you to write the custom code on
the server using JavaScript.
Secure Proxy It helps you to close domain calls and also allows you to keep
sensitive data on the server. E.g. API keys usernames, URLs.
API
The platform is very easy to any third party API. So anything available on the internet
from obvious API providers such as Twitter, Facebook, Salesforce ASAP, IBM you
can add any REST APIs[7][8] and use while building a mobile app. It doesnt matter
if it requires any API key or authentication; a user can use the API in the app.
Enterprise Integration Server
One of the main feature that it provides different data sources for e.g. Database,
SDL, LDAP within an enterprise or within your organization. The user can use this
layer to expose the data source using the REST APIs. So any data source which is
exposed via rest API, you can use it in your app. There are also features like
Authentication, Offline, and Social Integration.
When a user builds hybrid app like using the camera, you need to test the app on
the device but installing the app every time on the device is very time-consuming. So
it allows testing native app without having to install the app on the device each time.
Lastly, you can build a team of developers to work on your append then you can
assign different roles and different permissions. This capability is built into the
platform. [1][6]
3) Implementation:
Build a GeoLocation app that includes the following functionalities
-
Name
nav_menu
List Items
list_features
Button
Open_panel
Input
From, to
Item List
Mapping_list
Description
To select the list
items from the
navigation menu
To list the various
functionalities
present in the app to
navigate to the
selected
functionality
To open the
navigation panel
Text box to enter the
source and
destination address.
To display the
Button
Show_route
values present in
the database
To display the
routing between
cities onto the map
Visual Builder provides drag and drop for different UI components. The above
control types are dragged from the visual builder and dropped onto the mobile
screen. We can use different properties like Placeholder, icons, image etc for each
component.
Functionalities included
My Location: This functionality shows the current location of the user. This
functionality requires the location feature of the device.
Show Traffic: This will show the traffic layer on the map around the location.
Hide Traffic: This will hide the traffic layer.
Show Routing: This will display the routing information between the source
address and the destination address onto the map.
Locate Places: This will locate the location for the places user has entered into
the input textbox.
Clear Map: This will clear the map and no traffic or location will be displayed on
the map.
GPS: This will trigger users current location in the form of latitude and
longitude and store into the database.
In this case, we will use the latitude and longitude information from the geolocation
service and then map the values into the local storage variables markerLat and
markerLng. After the geolocation service is executed successfully, we use the
latitude and longitude information present in the markerLat and markerLng
variables to find the location on the map and drop the marker on the current
location.
This is done using the following javascript code
var markerLatLng = new
google.maps.LatLng(localStorage.getItem('markerLat'),
localStorage.getItem('markerLng'));
var marker = new google.maps.Marker({
position: markerLatLng,
map: map,
title: 'My position',
animation: google.maps.Animation.DROP
});
markers.push(marker);
bounds.extend(markerLatLng);
map.fitBounds(bounds);
map.setZoom(10);
In the above code, we are reading the latitude and longitude from the local storage
variables and then using the Google maps API to creating the new marker and
place the marker onto the map.
Before that, we created a javascript file which will initialize() the map with the
default location provided and displays the map when the main page loads.
var directionsDisplay;
var map;
var markers = [];
var directionsService = new google.maps.DirectionsService();
var bounds = new google.maps.LatLngBounds();
var trafficLayer = new google.maps.TrafficLayer();
function initialize() {
console.log('Initializing...');
map = Apperyio("google_map").gmap;
if (!map) {
setDelay();
} else {
directionsDisplay = new google.maps.DirectionsRenderer();
}
}
function displayDirections(sourceAddress, destinationAddress, map) {
var request = {
origin: sourceAddress,
destination: destinationAddress,
travelMode: google.maps.DirectionsTravelMode.DRIVING
};
directionsService.route(request, function(response, status) {
directionsDisplay.setMap(map);
if (status == google.maps.DirectionsStatus.OK) {
directionsDisplay.setDirections(response);
} else {
alert("Directions query unsuccessful. Response status: " +
status);
}
});
}
function setDelay() {
setTimeout(initialize, 50);
}
2) Show Traffic
To display the traffic for a particular location, we wrote the following code
trafficLayer.setMap(map);
Apperyio('nav_menu').panel('close');
Here we set the traffic layer onto the map which will use the current location and
then close the navigation panel to display the map page.
directionsDisplay.setMap(map);
if (status == google.maps.DirectionsStatus.OK) {
directionsDisplay.setDirections(response);
} else {
alert("Directions query unsuccessful. Response status: " + status);
}
});
}
If we see how the map is set right so that we can see the entire route and if we want
to see the traffic then we can click on the show traffic link to show the traffic around.
4) Clear map
Finally the map displayed for current location, traffic or routing can be cleared using
the clear map. On click of the clear map, the map is assigned a null value thus
clearing the map.
for (var i=0; i< markers.length; i++) {
markers[i].setMap(null);
}
directionsDisplay.setMap(null);
trafficLayer.setMap(null);
Apperyio('nav_menu').panel('close');
Now we will create a REST service which will use the geocoding API to convert
the location into latitude and longitude information.
Google Maps Geocoding API
Required parameters in a geocoding request:
Address - The street address that you want to geocode, in the format used
by the national postal service of the country concerned. Additional address
elements such as business names and unit, suite or floor numbers should
be avoided.
Key - Your application's API key. This key identifies your application for
purposes of quota management.
Geocoding Responses
Geocoding responses are returned in the format indicated by the output flag
within the URL request's path. In this example, the Google Maps Geocoding API
requests a JSON response for a query on "1600 Amphitheatre Parkway,
Mountain View, CA".
This request demonstrates using the JSON output flag:
https://maps.googleapis.com/maps/api/geocode/json
Sample JSON response
{
"results" : [
{
"address_components" : [
{
"long_name" : "1600",
"short_name" : "1600",
"types" : [ "street_number" ]
},
{
"long_name" : "Amphitheatre Pkwy",
"short_name" : "Amphitheatre Pkwy",
"types" : [ "route" ]
},
{
"long_name" : "Mountain View",
"short_name" : "Mountain View",
"types" : [ "locality", "political" ]
},
{
"long_name" : "Santa Clara County",
"short_name" : "Santa Clara County",
"types" : [ "administrative_area_level_2", "political" ]
},
{
"long_name" : "California",
"short_name" : "CA",
"types" : [ "administrative_area_level_1", "political" ]
},
{
"long_name" : "United States",
"short_name" : "US",
"types" : [ "country", "political" ]
},
{
"long_name" : "94043",
"short_name" : "94043",
"types" : [ "postal_code" ]
}
],
"formatted_address" : "1600 Amphitheatre Parkway, Mountain View, CA
94043, USA",
"geometry" : {
"location" : {
"lat" : 37.4224764,
"lng" : -122.0842499
},
"location_type" : "ROOFTOP",
"viewport" : {
"northeast" : {
"lat" : 37.4238253802915,
"lng" : -122.0829009197085
},
"southwest" : {
"lat" : 37.4211274197085,
"lng" : -122.0855988802915
}
}
},
"place_id" : "ChIJ2eUgeAK6j4ARbn5u_wAGqWA",
"types" : [ "street_address" ]
}
],
"status" : "OK"
}
https://developers.google.com/maps/documentation/geocoding/intro#Geocoding
Responses
We have provided the Geocode API URL and in the Request tab of Geocoding
service, we have added the two parameters components
-
address
key.
The API key is generated using the Google Developers Console and is used as a
parameter for geocoding service.
Then we can test the service by providing the address in the address parameter.
The important thing is appery.io provides facility to import the responses from the
service and this response can be used for data mapping and we need not write
the complete response manually.
c) Create Data source for the service and perform data mapping
Once the service is setup, we create the data source for the service so that we
can use the service for data mapping. Before send event, the address entered
into the address field in the UI is mapped to the geocoding service parameter.
After success event, the latitude and longitude details from the service are
mapped to the map latitude and longitude fields and also with the marker latitude
and longitude fields.
6) GPS Tracking
a) This functionality will track the users current location with the help of device GPS
sensor and then insert the location into the database. The GPS location is
tracked every 7 seconds and saved into the platform database. The location is
saved in the form [lng, lat] in the database. The timer can be changed to the limit
as per the user requirement.
b) Create user interface using the visual builder
The following fields are required to implement GPS tracking:
- My location field The longitude and latitude information will be
displayed into this field.
- Update Interval(sec) This will display the tie interval for which the
location is to be tracked. If the field says 7 seconds then after
every 7 seconds the location will be tracked and stored in the
database.
- Location Tracking This is a toggle button that provides the on and
off functionality for the tracking. If the button is turned off, then the
device will no longer track the location
c) Add the Geolocation service to the data source and perform data mapping
We will add the data source for the GeoLocation service for this page and
provide the mapping on the success of the GeoLocation service. The latitude and
longitude values from the service are mapped to the local storage variables
markerLat and markerLng. This means that after the service is executed
successfully, the latitude and longitude values will be stored in the local storage
variables and then these values will be filled into the My location field with the
use of the following code.
Apperyio("my_location").val(localStorage.getItem("markerLat")
+","+localStorage.getItem("markerLng"));
d) Create database service to store the location into the database
Click on the Database link present on the top right of the Appery.io to navigate to
the database page. Click on the Create new database button and create the
database named gps_location_db. Next to create different tables in the existing
database, click on the create new collection Location. So database and table are
ready and now we add different columns.
+Col Add columns
-Col Delete columns
Edit Col Edit column
+Row Add new row
-Row Delete existing row
In our case, we have added Location column with type geopoint.
Create Service This service will take the latitude and longitude and insert into
the database.
g) Add actions for different events
Now we will invoke different services when the user performs a particular event.
After the GeoLocation service is executed, we will invoke the create service. So
after every 7 seconds, the location is tracked and the value is placed into the My
Location field and then the create service is invoked that will store the location
values into the database. Before we load the create service, We need to invoke
the GeoLocation service on the page. So when the Page loads, we will invoke
the geolocation service using the below code
geolocation2.execute({});
gps_interval = setInterval(function(){
geolocation2.execute({});
},
Apperyio('tracking_interval').val() * 1000
);
The location tracking can be stopped by switching off the toggle button. It works
as shown below.
if (gps_interval == null)
{
gps_interval = setInterval(function(){
geolocation2.execute({});
},
Apperyio('tracking_interval').val() * 1000);
} else
{
clearInterval(gps_interval);
gps_interval = null;
}
The above code will check if the toggle button is ON, then it will set the interval to
the value provided in the field. And if the toggle button is OFF, then it will clear
the interval and location will no longer be tracked.
Cordova
Apperyio mobile base
Jquerymobile
Jquery-ui-map
customEventHandler
My Location
Traffic->Show
Traffic->Hide
Locate Placecs->Show
Clear Map
GPS
To find the current location of the user, click on the My Location item under the
navigation panel. If the location service of the device is switched off then it will ask the
user to switch on the device so that the GeoLocation API can access the location of the
device and then the marker will be shown on your current location.
Again open the navigation panel and click on the show traffic item. As per the above
screenshot, you can see the traffic displayed around the current location. We can clear
the map by clicking on the Clear Map link in the navigation panel.
Implementation Success/Failure
Geo location Feature: The core functionality of the system is to access the location of
the user and give him suggestion on the basis of his location. This feature is correctly
implemented in our system.
Routing feature: We are able to route user from one location to other desired location
and traffic conditions in routing too. The routing function can also be cleared from the
map.
Locate place from the database We wanted to add places and its features in the
database. This would have served as various options on the map for the user. We were
able to add places in the database but those places didnt show up on the map. For
example we added food places in the database but this places didnt show up in the
map.
GPS we implemented location tracking of the user. The GPS tracker adds the current
position of the user in the database. The position of the user is added in the system
after every seven seconds.
Real time tracking of the location When a user moves around the continuous location
of the user cant be shown in the map.
Framework
Appery.io
HTML 5
CSS
JS
Ionic
Angular JS
Bootstrap
Jquery Mobile
Meteor
HTML 5
CSS
JS
Angular JS
Bootstrap
React Js
Jquery
React JS
MongoDB
Blaze
React
Angular
Database
User interface
MongoDB
Jquery Mobile
HTML 5
GOOGLE Map
Carousel
Protocols
Database
Integration
Integrated APIs
REST APIs
Inbuilt services
Geolocation
Barcode
Camera
Contacts
Cordova
Paypal
Twitter
Service pattern Mobile
Github
facebook
available
MongoDB
Authorization
Available
Not available
Github support
Pluggin support
Robomongo
MiniMongo
Meteor SDK
Underscore.js
REST APIs
Leaflet
Cordova
Github
Iron: handler
Ratchet
Not available
Testing
environment
Pricing
Hosting
Critical Analysis
The findings and claims in this section are based upon, our own experience while
developing mobile application on Meteor and Appery.io
1) Meteor has its own packages for everything and one has to figure out which
package should be used for developing the application. Though it supports a rich set of
APIs , a lot of time was spent on figuring out which of the existing NodeJS and browser
packages to be used for development purpose.
Appery.io is the easiest mobile app maker software .Even for starters; you can generate
a complete application in minutes. We were able to figure out the APIs and plugin easily
for our mobile application
2) Meteor has no visual builder facility for mobile application development. This
means everything has to be coded from scratch.
Appery.io provides a visual builder for developing mobile applications. Drag and Drop
facility for UI components makes it really easy to develop a front end. The code for the
application is automatically generated on the back end by Appery.io.
3) Meteor can work very fine with CSS, Cordova and Javascript which makes it
perfect for dynamic web applications. Although to work with the web and mobile (hybrid
web application) it requires lots of overhead coding and embedding numerous APIs.
Appery.io has a built in feature called services implementation, where you can actually
decide which service you want to actually implement in your web application. Once you
choose the service the rest is done by Appery.io
4) Making the call to Google APIs is a herculean task in Meteor. Once you make the
call to Googles API you need to take care of request header and response format. One
has to install HTTP library to even use basic HTTP request call. HTTP packet,
iron:handler and ratchet ,these 3 libraries were required to make a successful call to the
Google API.
Appery.io has in built service called Geolocation which helps in making calls to Googles
API. It is very easy to add Google APIs in Appery.io. Appery.io basically provides a
simple dialogue box to choose various parameters for API call and then generates the
call automatically for the user.
Appery.io also uses Mongo database but it provides an inbuilt integrated front end for
database insertion and manipulation. We can easily map UI component to a local
variable and this would be initialized when the service is executed.
6) Meteor Apps are fully stateful means the connection between the server and the
client is implicitly synchronized .this results into fat connection and poses scalability
problem
Appery.io has a token associated with the session which determines the statefulness
between the server and the client.
Appery.io allows you only 15 days free trial period to develop the application on it. It
charges whopping $30 per month for even building the Application on its platform. If you
have access to Appery.io account you can host for free within your trial period and there
is no extra charge for deployment once you opt for the basic subscription package.
Implementation
Testing
Home
page
and My
location Appery.io
navigation panel in functionality
in application
Appery.io
Appery.io
testing
on
native
platform
Cordova
Implementing
Testing
implementation
for geolocation and geolocation
cross
platform geocoding APIs
and
compatibility in mobile
geocoding
devices
services
on
mobile
platforms
Core theme and css Core
routing Testing
of
Appery.io
with facility
latitude and
BootStrap
longitude
location
details
with
data provided
by
GPS
tracking.
Database design in Google
map Testing
Appery.io
implementation
Appery.io
application
during cloud
deployment
Analysis
/Research
Bootstrap
Jquery
Mobile
Cordova
Google APIs
6
7
Designing
Leaflet
implementation
Meteor
Cordova
implementation to
support
GUI
in
various
mobile
platforms
User interface for
Locate places and
GPS tracking page
in Appery.io
Database design in
Meteor application
Implementation
Iron router
in Meteor
Testing
Analysis
/Research
Session
state
and
Google
Maps API in
Meteor
application
Implementing
Maps
in
Appery.io
Testing
Ratchet
Appery.io on
android
devices
Testing
Iron:handler
Google APIs
call
on
Postman
Routing Facility
Jquery
implementation
Mobile
in Appery.io
Github
Repository
Meteor
for
Final report
writing
Comparison
between
Meteor and
Appety.io
Conclusion:
In this paper, we tried to compare two cloud platforms that offer mobile web
development. We researched for any previous work done in the area but there is no
substantial research done, which compares two cloud platform that offers development
of mobile application. This comparison was all about using two modern fast developing
and full stack Javascript platform for developing a mobile application on cloud platforms.
Overall we faced two main challenges with Meteor. It supports reactive programming so
the learning curve is very big. Developer spends more time on thinking about the
libraries and collection that are needed to develop the application and where to fit them
in business logic and user interface. The second issue is ,that Meteor is still in beta
state. We had so many instances where we were stuck to find feasible workarounds
and digging the internet for solutions. Although we will like to mention that it is a very
powerful tool to create applications with its expanding Javascript libraries. Meteor is
best if you start thinking reactively.
Appery.io the only drag-and-drop cloud-based mobile application development
platform. While most of other cloud platforms would require you to download and install
some software on your hardware, Appery.io is totally based on the cloud. Support for
cross-platform, interactive GUI builder, Drag, and drop facility makes it the first choice
for novice developers. Although Appry.io provides most of the facility to develop mobile
applications there is a problem of slow response time in the application. The biggest
factor is that even development of the application is not free on Appery.io. This is a
development heaven for novice developers but less chance of developing some new
solutions.
Our references would be mostly from the working and on hands practical experience
with Appery.io and Meteor. We wanted to make a comparison on the basis of user
interpretation of the two technologies . So we choose practical references rather than
going for research papers.
References:
[1] James Urquhart. The need for a standard cloud taxonomy. CNet News, The Wisdom
of Clouds. http://news.cnet.com/8301-19413_3-10148806-240.html.
[2] Gartner Says Contrasting Views on Cloud Computing Are Creating Confusion.
http://www.gartner.com/it/page.jsp?id=766215.
[3] Amazon Elastic Compute Cloud (Amazon EC2). http://aws.amazon.com/ec2/.
[4] Google App Engine. http://code.google.com/appengine/.
[5] S. Xinogalos, K. E. Psannis, and A. Sifaleras, "Recent advancesdelivered by HTML 5
in mobile cloud computing applications: a survey," in Proc. the Fifth Balkan Conference
in Informatics, 2012, pp. 199-204.
[6] Khan, M. Othman, S. Madani, and S. Khan, "A survey of mobile cloud computing
application models," IEEE Communications Surveys & Tutorials, issue 99, 2013.
[7] Divya Narain. March 2009. ABI Research: Mobile Cloud Computing the Next Big
Thing, http://ipcommunications.tmcnet.com/topics/ip-communications/ articles/59519abi-research-mobile-cloud-computing-next-big-thing.htm
[8] "EJSON E DDP - Allan De Queiroz". Allan de Queiroz.
http://allandequeiroz.com/2015/09/27/ejson-e-ddp/
[9] Vanian, Jonathan (27 December 2014). https://gigaom.com/2014/12/27/Meteorwants-to-be-the-warp-drive-for-building-real-time-apps/
[10] "Building A Meteor.Js Mobile App With Cordova, Mongodb, And Ratchet".
https://www.youtube.com/watch?v=7iqdkVwtuvg
[11] Appery.io,. "Enterprise Mobile App Builder & MFbaas | Appery.Io".
https://appery.io/
[18] "Custom HTML Markers With Google Maps - Websites, Mobile And Ecommerce
Humaan".Websites, Mobile and eCommerce Humaan.
http://humaan.com/custom-html-markers-google-maps/
[19] "Working With The Google Maps API, Location, And Appery.Io (April 17, 2014)".
YouTube.
https://www.youtube.com/watch?v=LZOC_7vkWds