\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Mobile Application with Cloud Computing},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2014-01-15 (revised: 15 January 2014)}
\def\TheID{\makeatother }
\def\TheDate{2014-01-15}
\title{Mobile Application with Cloud Computing}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{  K.Bhavana}

\renewcommand\Authands{ and }

\date{\small \em Received: 6 December 2013 Accepted: 3 January 2014 Published: 15 January 2014}

\maketitle


\begin{abstract}
        


Smartphones enable a new, rich user experience in pervasive computing. The major problem with Smartphone is that hardware resources such as CPUs, memory and batteries are still limited. To solve this resource problem, many researchers have proposed architectures to use server resources in the cloud for mobile devices. This paper proposes a conceptual architecture where mobile application platform share the software as a service among multiple users on cloud server via network.

\end{abstract}


\keywords{android, multi-tenant, cloud, virtual smartphone.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{Introduction}]{Introduction}\par
he architecture for remotely using mobile application on server is called Mobile Application Platform on Cloud Server that intends to handle not only user data but also user applications in a cloud server. This approach changes the application lifecycle as follows. "Write once, run everywhere. Install once, use everywhere."Android is an open-source mobile OS initiated by Google. The main reason to select Android as a server platform is that it is able to run not only for Smartphone but also for x86 processor.\par
Software as a Service (SaaS) represents a novel paradigm and business model expressing the fact that companies do not have to purchase and maintain their own ICT infrastructure, but instead, acquire the services embodied by software from a third party. Here SaaS service is provided for mobile users. This paper proposes Android as a Server Platform that enables many users to use resources on remote cloud servers. This paper also proposes a multi-tenant architecture of Android on cloud server. 
\section[{a) Introduction}]{a) Introduction}\par
The various definitions focus on what is believed to be the key aspects of multi-tenancy: a. The ability of the application to share hardware resources. b. The availability of a high degree of configuration of the software. c. The architectural approach in which the tenants (or users) make use of a single application and database instance. 
\section[{b) Multi-tenant Versus Multi-User}]{b) Multi-tenant Versus Multi-User}\par
It is necessary to make an important, but subtle distinction between the concepts multi-tenant and multiuser. In a multi-user application it is assumed that all users are using the same application with limited configuration options. In a multi-tenant application, it is assumed that each tenant has the possibility to heavily configure the application. This results in the situation that, although tenants are using the same building blocks in their configuration, the appearance or workflow of the application may be different for two tenants. 
\section[{c) Architecture}]{c) Architecture}\par
Multi-tenancy is achieved through different approaches. The first approach is by running multiple users Virtual Machines in a server via a hypervisor. This approach has the advantage of application usability and maintenance. From the viewpoint of application usability, every mobile application that can run on Android-x86 is usable because each Android OS runs only one application.\par
The second approach implements multi-tenant function in kernel-layer. This approach changes Android OS to run multiple user applications in separate processes. This approach is similar to an ordinary thin client server running multiple user applications in a server. The main challenge is that original Android Multi-tenancy is an organizational approach for SaaS applications. Although SaaS is primarily perceived as a busi -ness model, its introduction has lead to numerous interesting problems and research in software engineering. Despite the growing body of research in this area, multi-tenancy is still relatively unexplored, despite the fact the concept of multi-tenancy first came to light around 2005.\par
Abstract-Smartphones enable a new, rich user experience in pervasive computing. The major problem with Smartphone is that hardware resources such as CPUs, memory and batteries are still limited. To solve this resource problem, many researchers have proposed architectures to use server resources in the cloud for mobile devices. This paper proposes a conceptual architecture where mobile application platform share the software as a service among multiple users on cloud server via network. 
\section[{II.}]{II.} 
\section[{Multi-Tenancy}]{Multi-Tenancy}\par
Multi-tenancy, this is defined as a feature where the software running on a server provides services to many users. It is one of the important features for cloud computing. From the viewpoint of both economy and ecology, it is beneficial to share hardware resources among users. Using a mobile OS would be more effective than using a desktop OS because the resource requirements of mobile OSs are smaller.\par
supports only one display and keypad device since Android is mainly designed to work on a Smartphone.\par
Another approach is to create a multi-tenant function at framework-layer, similar to existing Javabased multi-tenant framework. This approach remodels Android the framework and APIs to support multiple user applications. The main challenge is how to run existing Android applications in modified framework. 
\section[{d) Implementation}]{d) Implementation}\par
In the functional overview of the architecture two new functions are defined for enabling multi-tenant for Android. The first function is the multiple application controller installed in an Android OS, and the second is the user area manager located in a host OS. The multiple application controller enables running of multiple applications as if each application is running on independent physical Smartphone. It is important requirement to decrease implementation cost for Android OS because of maintenance about OS version up problem. The user area manager controls server resources and act as an interface between a terminal and the multiple application controllers.\par
When user wants to use an application, the user terminal contacts the user area manager and order to launch application. The user area manager checks the server resources and select which guest OS to run application. The multiple application controller launches the application based on an order from the user area manager. The user area manager returns VNC connection information such as IP address and port. The following variants of multi-tenancy can be distinguished
\begin{quote}
Terminal\end{quote}
\par
? Shared application, separate database.  
\section[{i. High Degree of Configurability}]{i. High Degree of Configurability}\par
In a single-tenant environment, every tenant has his own, (possibly) customized application instance. In contrast, in a multi-tenant setup, all tenants share the same application instance, although it must appear to them as if they are using a dedicated one. Because of this, a key requirement of multi-tenant applications is the possibility to configure and/or customize the application to a tenant's need, just like in single-tenancy . 
\section[{ii. Shared Application and Database Instance}]{ii. Shared Application and Database Instance}\par
A single-tenant application may have many running instances and they may all be different from each other because of customization. In multi-tenancy, these divergences no longer exist as the application is runtime configurable. This entails that in multi-tenancy the overall number of instances will clearly be much lower (ideally it will be one, but the application may be replicated for scalability purposes). As a consequence, deployment is much easier and cheaper. Year B performance will be similar to the source node, the overall performance of the task will be worse than running it on a single device due to the migration overhead. Therefore it is needed to explore what makes the offloading to similar devices beneficial.\par
On an economical basis, accessing cloud computing providers is associated with two costs: the cost of networking plus the cost of using the provider's resources. The latter is not high nowadays -it can be as cheap as 5 USD per month considering the access of a small on-demand server 2 hours per day 2 -but is expected to increase to reach higher levels of uptime and better support .\par
On the other hand, wireless data fee is still high. As an example, in South Korea the subscription plans for the i-phone 3GS (32GB) are near 70 USD per month, and if the user wants to download 1 GB of data he has to pay more than 200 USD. Besides, using 3G connectivity consumes more battery and is slower than network interactions with nearby devices using other interface such as WiFi.\par
On a technical side, there are several benefits to consider: First, it is necessary to preserve conventional offloading benefits, such as allowing applications that cannot, otherwise, be executed on mobile devices due to a lack of resources. For example, if memory is not enough then creating instances of those objects on any remote device will allow the application to be executed. Second, performance can be enhanced if the execution sequence of an application can be reordered for increasing the level of parallelism. The process for the creation and usage of a virtual cloud provider is simple: If a user is at a stable place and wants to execute a task which needs more resources than available at the device, the system listens for nodes in the vicinity. If available, the system intercepts the application loading and modifies the application in order to use the virtual cloud. To support this process, the architecture proposed consists of five main features: Application manager; Resource manager; Context manager; P2P component and; Offloading manager. 
\section[{b) Architecture}]{b) Architecture} 
\section[{i. Application Manager}]{i. Application Manager}\par
It is in charge of launching and intercepting an application at loading time and modifying and application to add features required for offloadingproxy creation, RPC support -according to the current context. Since the idea is to replace calls to infrastructure-based clouds, the interception and modification should focus on modifying the reference to that provider with a reference to the virtual provider. This process is performed when an application is executed the First time. Once an application is modified, its modified copy is used to avoid further delays.\par
The Resource Manager: It is in charge of application profiling and resource monitoring on a local device. For each application, a profile is defined in terms of the number of remote devices needed to create a virtual cloud, and sensibility to privacy and amount of resources needed for the migration to happen (in average). This profile is checked by the application manager whenever an application is executed in order to determine whether an instance of the virtual provider should be created or not. 
\section[{ii. The Context Manager}]{ii. The Context Manager}\par
It wields and synchronizes contextual information from context widgets and makes it available in some way for other processes. It is composed by three subcomponents: context widgets that communicate with the sources of information; a context manager itself that handles the information and extracts new contexts from them; and a social manager that is used to store the knowledge regarding relationship between users. 
\section[{iii. P2p Component}]{iii. P2p Component}\par
Two basic contexts are of utter importance are the location and number of nearby devices. The former is used for the mobility traces. The later for the enabling of a cloud from the application manager, and it is given by the P2P component. This component is aware of the status of the devices in the surroundings: it sends events to the context manager in case a new device enters the space, or if an existing device leaves the space. It utilizes an ad hoc discovery mechanism, and then groups the nodes using a P2P scheme, allowing for better scalability and distribution of contents.\par
Once that information is captured, a context aggregator located in the context manager generates high level contexts from the basic contexts. They represent the consolidated information related to the user. It is only defined with one high level context for this framework, which is whether the user is in a stable location or not. Offloading manager component: It is in charge of sending and managing jobs from the node to other remote devices, plus receiving and processing jobs sent from them. It communicates with the P2P component once a job is issued to the respective node, and waits for the results to be delivered back to the application. This component is the one in charge of detecting failures in the execution and to re-emit them. It also is in charge of creating protected spaces for the execution of the tasks coming from remote nodes. This protected spaces (represented here as a VM), are utilized to block the access to sensitive data located on the devices 
\section[{c) Implementation}]{c) Implementation}\par
A prototype is implemented with framework in Java. It was selected because it provides all the needed capabilities in terms of intercepting the loading, modifying the classes and also there were implementations available for cloud computing providers and clients on top of this platform. A main issue was to modify applications in order to intercept and replace references to infrastructure-based clouds with mobile ones. In Java, code interception can be done using bytecoders in conjunction with a personalized class loader component, built on top of regular JVM loader. A bytecode generator creates and injects the needed code, while the loader allows the interception of the classes before loading them in memory. A personalized version of Javassist[14] was utilized for this purpose.\par
Communication between devices is based on the Extensible Messaging and Presence Protocol (XMPP). Yaja! I is modified as a XMPP client is implemented in Java. The modifications allow us to be able to execute Yaja! on mobile devices and to incorporate two extensions for XMPP: Serverless Messaging8 and Jabber RPC9. The former is based on mDNS and ZeroConf, and allows for the discovery and messaging among devices without the need of an infrastructure. The latter is a scheme based on XML-RPC using XMPP as the transport protocol, and it is utilized to execute the remote tasks associated with a cloud job. 
\section[{IV.}]{IV.}\par
Virtual Smartphone Over IP Virtual Smartphone over IP, which provides cloud computing environment specifically tailored for smartphone users. It allows users to create virtual smartphone images in the cloud and to remotely run their mobile applications in these images as they would locally. The motivation is to allow smartphone users to more easily tap into the power of the cloud and to free themselves from the limit of processing power, memory and battery life of a physical smartphone. Using the system, smartphone users can choose to install their mobile applications either locally or in the cloud.\par
Running applications remotely in the cloud has a number of advantages, such as avoiding untrusted applications from accessing local data, boosting computing resources, continuing to run applications on the background and opening up new way to use smartphones.\par
Virtual Smartphone over IP system adopts architecture similar to ones commonly used by server hosting providers. As illustrated, the system is composed of a number of external smartphone clients, a front-end server, a virtual smartphone farm, a management server and a network file system (NFS).\par
? Virtual smartphone farm is the most important component of the system. It is a virtualization environment that hosts a collection of virtual smartphone images, each of which is dedicated to a smartphone user.\par
? The front-end server admits service requests from smartphone users across the Internet and establishes remote sessions to the appropriate virtual smartphone images. The frond-end server also allows smartphone users to create, configure and destroy virtual smartphone images. Once a remote session is established, the user can install and run mobile applications on one of these images instead own physical smartphone. ? The network file system is used by virtual smartphones for all persistent file storage, in much the same way that an SD card holds data for physical smartphones. Since the NFS is easily scalable, it practically provides each virtual smartphone unlimited file storage. Users control their virtual smartphone images through a dedicated client application installed on their smartphones. This client application receives the screen output of a virtual smartphone image and presents the screen locally in the same way as conventional thinclient technology. Since it is expect that most users to access their virtual smartphone images through an unstable network such as 3G, the image must continue to run on the farm and be in the same state when the user is connected again after the user is disconnected in an expected manner. 
\section[{a) Implementation}]{a) Implementation}\par
A proof-of-concept prototype is proposed using Android, an open-source mobile OS initiated by Google. The main reason behind the choice is that Android OS is not only designed for smartphone devices with an ARM processor, but also is being ported to the x86 platform \hyperref[b3]{[4]}. Although Android-x86 is originally intended for netbooks, it gives us an opportunity to create a virtual image of Android using a bare-metal hypervisor. This allows each virtual Android-x86 image to tap into the power of server hardware in a data center. The fact that a CPU emulator is not needed (i.e. x86-to-ARM) to run the virtual image is very important since such emulator always introduces enormous overhead and may neutralize any performance advantage offered by a data center. The client program transmits various events from the physical device to the virtual smartphone and receives graphical screen updates from the virtual smartphone.\par
A virtual sensor driver can also be implemented in the Android-x86 image. Most modern smartphones are equipped with various sensor devices such as GPS, accelerometer and thermometers. While VNC itself supports only keyboard and mouse as the primarily input devices, it can also be extended where client program can transmit sensor readings (accelerometer, orientation, magnetic field and temperature etc) to the virtual sensor driver in the Android-x86 image. The virtual sensor driver is implemented in such a way that the sensor readings from the physical Android device would appear to come from the Anroid-x86 images itself. This is an important feature as it allows Android applications in an Android-x86 image to obtain sensor readings from the physical smartphone without any modification.\par
Proposed prototype allows applications running in the cloud to appear like local applications on the physical device, with functions such as copy-and-paste between local and remote applications. The prototype also features remote shortcuts to remote applications in the virtual smartphone that minimize the number of steps required for users to launch remote applications.\par
Furthermore, each short-cut can point to a different virtual Android-x86 image, and thus allowing users instant access to remote applications residing in multiple Android-x86 images in one single menu.\par
V. 
\section[{Android OS}]{Android OS}\par
The reasons where run Android OS on hypervisor is implemented are as follows:\par
? Maintenance: An OS image is easy to backup, restore, and check the server environment similar to other hypervisor-based virtualization.  From the viewpoint of the Android application lifecycle, only one application can use the display, and the other applications automatically run in the background process. To solve this issue, multiple display device support and application mapping is required.\par
Data Security Integration: The Android has security mechanism to protect the application data sector from other application using user account based access control. Of course Android is not designed to use same application for different users. So, if users share same application data sector, mixing of unexpected user data may occur.\par
There are two approaches to solve this problem. One is virtual SD card approach. When all user accesses to SD card is controlled, it can prevent access to another user's application data. The benefit of this approach is that implementation impact is limited to SD card driver. Second approach is using a file system function. GNU chroot enables changing the application root directory dynamically. This approach would also prevent unexpected file access. 
\section[{VI.}]{VI.} 
\section[{Conclusion}]{Conclusion}\par
This paper, proposes Android as a Server Platform system that enables the use of sharing serverside Android OS among multiple users. It is possible to develop a prototype system about proposed multitenant Android architecture. It is believed that proposed architecture shows high performance on virtual imagebased virtualization for mobile applications.\par
VII.\begin{figure}[htbp]
\noindent\textbf{1}\includegraphics[]{image-2.png}
\caption{\label{fig_1}Figure 1 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{2}\includegraphics[]{image-3.png}
\caption{\label{fig_2}Figure 2 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{3}\includegraphics[]{image-4.png}
\caption{\label{fig_3}Figure 3 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{4}\includegraphics[]{image-5.png}
\caption{\label{fig_5}Figure 4 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{5}\includegraphics[]{image-6.png}
\caption{\label{fig_6}Figure 5 :}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-7.png}
\caption{\label{fig_7}B}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{}
\end{longtable} \par
 
\caption{\label{tab_0}?}\end{figure}
 \begin{figure}[htbp]
\noindent\textbf{} \par 
\begin{longtable}{P{0.85\textwidth}}
? Application Environment: The Android OS has\\
backward compatibility regarding application\\
runtime. For example, an application that is made\\
for Android 1.6 runtime can work in Android 2.1\\
runtime. However, device information such as\\
sensor, keyboard, and display size, varies from\\
one physical device to another. Running Android\\
OS in various setting is simple method to keep\\
application environment.\\
? CPU management:\end{longtable} \par
 
\caption{\label{tab_1}}\end{figure}
 			\footnote{© 2014 Global Journals Inc. (US)} 		 		\backmatter   			 
\subsection[{Acknowledgment}]{Acknowledgment}\par
I am really thankful to the Almighty. I am also thankful to my guide Mrs. Roselin Mary, HOD of Computer Science Department, AIHT, who helped me for various researches in the project. I also convey my thanks to all the staff members of AIHT for helping me out in this project. 			  			  				\begin{bibitemlist}{1}
\bibitem[ Application Fundamentals | Android Developers]{b7}\label{b7} 	 		\textit{},  		 \url{http://developer.android.com/guide/topics/fundame-ntals.html}  	 	 		\textit{Application Fundamentals | Android Developers}  		 	 
\bibitem[H-Canepa and Lee ()]{b1}\label{b1} 	 		\textit{A Virtual Cloud Computiong Privoder for Mobile Devices},  		 			G H-Canepa 		,  		 			D Lee 		.  		 MCS'10.  		2010. San Francisco.  	 
\bibitem[Android-x86 Project -Run Android on Your PC(Android-x86 -Porting Android to x86]{b6}\label{b6} 	 		 \url{http://www.android-x86.org/}  		\textit{Android-x86 Project -Run Android on Your PC(Android-x86 -Porting Android to x86},  				 	 
\bibitem[Chun and Maniatis]{b2}\label{b2} 	 		\textit{Augmented Smartphone Applications Through Clone Cloud Execution},  		 			B G Chun 		,  		 			P Maniatis 		.  		 	 
\bibitem[Royon and Frenot ()]{b3}\label{b3} 	 		\textit{Mouel Virtualization of Service Gateways in Multi-provider Environments},  		 			Y Royon 		,  		 			S Frenot 		,  		 			FL 		.  		2006. 2006. Heidelberg : CBSE.  	 
\bibitem[Bezemer and Zaidman ()]{b4}\label{b4} 	 		‘Multi-Tenant SaaS Applications: Maintenance Dream or Nightmare?’.  		 			C P Bezemer 		,  		 			A Zaidman 		.  	 	 		\textit{IWPSE-EVOL' 10},  				 (Antwerp, Belgium)  		2010.  	 
\bibitem[Satyanarayanan et al. ()]{b0}\label{b0} 	 		‘The Case for VM-based Cloudlets in Mobile Computing’.  		 			M Satyanarayanan 		,  		 			V Bahl 		,  		 			R Caceres 		,  		 			N Davies 		.  	 	 		\textit{IEEE Pervasive Computing}  		2009.  	 
\bibitem[Chen and Ito ()]{b5}\label{b5} 	 		\textit{Virtual Smartphone over IP},  		 			E Y Chen 		,  		 			M Ito 		.  		2010. Montreal,QC, Canada: IEEE WOWMOM.  	 
\end{bibitemlist}
 			 		 	 
\end{document}
