FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
THE PATENTS RULES, 2003
COMPLETE
SPECIFICATION
(See section 10; rule 13)
TITLE OF THE INVENTION
METHOD AND SYSTEM FOR DEVELOPING MULTI-PLATFORM APPLICATIONS
APPLICANT
JIO PLATFORMS LIMITED
of Office-101, Saffron, Nr. Centre Point, Panchwati 5 Rasta, Ambawadi,
Ahmedabad - 380006, Gujarat, India; Nationality: India
The following specification particularly describes
the invention and the manner in which
it is to be performed
2
TECHNICAL FIELD
[0001] The present disclosure relates generally to the field of mobile device
applications. More particularly, the present disclosure relates to systems and methods
for developing multi-platform applications with a unified codebase and platform5 specific adaptations.
DEFINITIONS
[0002] As used in the present disclosure, the following terms are generally
intended to have the meaning as set forth below, except to the extent that the context
in which they are used to indicate otherwise.
10 [0003] The term “Applications” refers to programs designed to perform specific
tasks for end-users.
[0004] The term “Application deployment” refers to a process of making a
software application available for use, from development to reaching end-users. It
involves packaging, transferring, and setting up the application on a target
15 environment, whether it's a server, device, or cloud infrastructure. The application
deployment is a phase that ensures the application is accessible and functional for its
intended users.
[0005] The term “Application development framework” refers to a set of pre-built
tools and libraries that streamline the process of creating software applications. It
20 provides a standardized structure and common functionalities, allowing developers to
build applications more efficiently and with less code.
[0006] The term “Platform” refers to a framework of tools, services, and
technologies that provides a foundation for building, deploying, and managing the
applications. The multiple platforms comprise iOS, Android, and web desktop.
3
[0007] The term “Codebase” refers to a source code used to build a software
system, application, or component. It encompasses all the source files, configuration
files, and other resources needed to compile and run the software/application.
Codebases are essential for software/application development, facilitating version
5 control, collaboration, and ongoing maintenance.
[0008] The term “Distribution channel” refers to a path used to get a
software/application from the developer to the end-user. These channels are specific to
the target platform (e.g., Android, iOS, Web, Desktop) and are responsible for hosting,
updating, and distributing the application securely and efficiently.
10 [0009] The term “Application Programming Interface (API)” refers to a set of
rules and specifications that allow different software/application programs developed
by different teams or using different programming languages to communicate and
interact with each other, enabling them to exchange data and functionality.
[0010] The term “Authentication mechanism” refers to a process used to verify the
15 identity of a user before granting access to the application/software.
[0011] The term “Security protocol” refers to a set of rules designed to protect
data, applications, software and systems from unauthorized access, use, disruption,
modification, or destruction. These protocols ensure confidentiality, authenticity, and
integrity.
20 [0012] These definitions are in addition to those expressed in the art.
BACKGROUND
[0013] The following description of related art is intended to provide background
information pertaining to the field of the disclosure. This section may include certain
aspects of the art that may be related to various features of the present disclosure.
4
However, it should be appreciated that this section be used only to enhance the
understanding of the reader with respect to the present disclosure, and not as
admissions of prior art.
[0014] In the evolving landscape of software development, the demand for
5 applications that run seamlessly across multiple platforms continues to grow.
Developing applications for multiple platforms (e.g., mobile, web) traditionally
requires writing separate codebases for each target platform. This approach can be
time-consuming and resource-intensive, as the developers need to duplicate effort by
creating and maintaining separate codebases for each platform. Further, the traditional
10 approach can be inefficient for maintenance as the updates and bug fixes require
changes to be implemented across all codebases, increasing development overhead.
Furthermore, applications might look and function differently across platforms,
potentially confusing users.
[0015] To address these challenges, the cross-platform development frameworks
15 have emerged. These frameworks allow developers to write a single codebase that can
be adapted and deployed across various platforms. However, some limitations persist.
[0016] Further, despite the benefits of code reuse facilitated by frameworks,
achieving a fully native user experience on each platform remains challenging due to
limited platform-specific customization. While cross-platform development
20 streamlines the process, certain platform-specific nuances may be difficult to replicate,
potentially compromising the user experience. Additionally, using APIs to expose
application functionalities introduces security concerns that demand meticulous
attention. Designing and implementing robust security measures, such as
authentication and authorization, becomes imperative to safeguard sensitive data and
25 ensure secure interactions between applications and services. Thus, while crossplatform development offers efficiency gains, addressing platform-specific
customization and security considerations remains essential for delivering high-quality
5
applications across diverse platforms.
[0017] Therefore, there is a need to overcome the limitations of the prior art.
OBJECTS
[0018] Some of the objects of the present disclosure, which at least one
5 embodiment herein satisfies, are as follows:
[0019] An object of the present disclosure is to utilize a single codebase (i.e.,
unified codebase) for writing applications that can be deployed across a plurality of
target platforms.
[0020] Another object of the present disclosure is to enable platform-specific
10 adaptations within the single codebase, ensuring a consistent and native user
experience across different target platforms.
[0021] Another object of the present disclosure is to enhance security measures in
cross-platform development by implementing robust authentication and authorization
methods to safeguard sensitive data and interactions between applications and services.
15 [0022] Another object of the present disclosure is to promote code efficiency and
reusability by facilitating the reuse of a substantial portion of code across different
platforms, minimizing redundancy, and streamlining development processes.
[0023] Another object of the present disclosure is to address platform-specific
customization challenges by providing developers with tools and methodologies to
20 achieve truly native user experience on each platform while leveraging the benefits of
cross-platform development.
[0024] Other objects and advantages of the present disclosure will be more
apparent from the following description, which is not intended to limit the scope of the
6
present disclosure.
SUMMARY
[0025] In an exemplary embodiment, a method for managing an application
deployment across a plurality of platforms is described. The method comprises
5 identifying, by an identification unit, an application development framework
supporting the plurality of platforms based on one or more attributes associated with
each of the plurality of platforms and an application. The method comprises creating,
by a processing unit, a unified codebase corresponding to the application associated
with each of the plurality of platforms using the identified application development
10 framework. The method comprises transforming, by the processing unit, the created
unified codebase created for the application into a platform-supported codebase
associated with each of the plurality of platforms using the identified application
development framework and deploying, by the processing unit, the transformed
platform-supported codebase to a distribution channel associated with each of the
15 plurality of platforms.
[0026] In some embodiments, for creating the unified codebase, the method
comprises: generating, by the processing unit, a standardized Application
Programming Interface (API) corresponding to one or more of a plurality of application
functionalities associated with the application and implementing, by the processing
20 unit, an authentication mechanism corresponding to the standardized API generated for
the one or more of the plurality of application functionalities associated with the
application.
[0027] In some embodiments, the method comprises: generating, by the
processing unit, a platform-specific code corresponding to the application based on one
25 or more platform functionalities associated with the platform using the identified
application development framework and integrating, by the processing unit, the
7
platform-specific code with the unified codebase associated with the application.
[0028] In some embodiments, the application is rendered to an end user based on
one or more native components associated with a platform of the plurality of platforms
supported by a user device of the end user.
5 [0029] In some embodiments, the method comprises: modifying, by the
processing unit, the unified codebase associated with the application based on one or
more parameters, wherein the one or more parameters comprise a new functionality,
an error, and a new security protocol. The method comprises updating, by the
processing unit, the platform-supported codebase associated with each of the plurality
10 of platforms based on the modified unified codebase using the identified application
development framework.
[0030] In another exemplary embodiment, a system for managing an application
deployment across a plurality of platforms is described. The system comprises an
identification unit configured to identify an application development framework
15 supporting the plurality of platforms based on one or more attributes associated with
each of the plurality of platforms and an application. A processing unit is configured
to create a unified codebase corresponding to the identified application associated with
each of the plurality of platforms using the identified application development
framework, to transform the created unified codebase corresponding to the application
20 into a platform-supported codebase associated with each of the plurality of platforms
using the identified application development framework, and to deploy the transformed
platform-supported codebase to a distribution channel associated with each of the
plurality of platforms.
[0031] In some embodiments, to create the unified codebase, the processing unit
25 is configured to generate a standardized Application Programming Interface (API)
corresponding to one or more of a plurality of application functionalities associated
8
with the application and to implement an authentication mechanism corresponding to
the standardized API generated for the one or more of the plurality of application
functionalities associated with the application.
[0032] In some embodiments, the processing unit is configured to generate a
5 platform-specific code corresponding to the application based on one or more platform
functionalities associated with the platform using the identified application
development framework and to integrate the platform-specific code with the unified
codebase associated with the application.
[0033] In some embodiments, the application is rendered to an end user based on
10 one or more native components associated with a platform of the plurality of platforms
supported by a user device of the end user.
[0034] In some embodiments, the processing unit is configured to modify the
unified codebase associated with the application based on one or more parameters,
wherein the one or more parameters comprise a new functionality, an error, and a new
15 security protocol. Further, the processing unit is configured to update the platformsupported codebase associated with each of the plurality of platforms based on the
modified unified codebase using the identified application development framework.
[0035] In yet another exemplary embodiment, a user equipment (UE)
communicatively coupled with a network, the coupling comprises steps of receiving,
20 by the network, a connection request from the UE, sending, by the network, an
acknowledgment of the connection request to the UE, and transmitting a plurality of
signals in response to the connection request. Based on the plurality of signals,
management of an application deployment across a plurality of platforms in a network
is performed by a method. The method comprises identifying, by an identification unit,
25 an application development framework supporting the plurality of platforms based on
one or more attributes associated with each of the plurality of platforms and an
9
application and creating, by a processing unit, a unified codebase corresponding to the
application associated with each of the plurality of platforms using the identified
application development framework. The method comprises transforming, by the
processing unit, the created unified codebase corresponding to the application into a
5 platform-supported codebase associated with each of the plurality of platforms using
the identified application development framework and deploying, by the processing
unit, the transformed platform-supported codebase to a distribution channel associated
with each of the plurality of platforms.
BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWING
10 [0036] The accompanying drawings, which are incorporated herein, and constitute
a part of this disclosure, illustrate exemplary embodiments of the disclosed methods
and systems in which like reference numerals refer to the same parts throughout the
different drawings. Components in the drawings are not necessarily to scale, emphasis
instead being placed upon clearly illustrating the principles of the present disclosure.
15 Some drawings may indicate the components using block diagrams and may not
represent the internal circuitry of each component. It will be appreciated by those
skilled in the art that disclosure of such drawings includes disclosure of electrical
components, electronic components or circuitry commonly used to implement such
components.
20 [0037] FIG. 1 illustrates an exemplary network architecture for implementing a
system for managing an application deployment across a plurality of platforms, in
accordance with an embodiment of the present disclosure.
[0038] FIG. 2A illustrates an exemplary block diagram of the system for managing
the application deployment across the plurality of platforms, in accordance with an
25 embodiment of the present disclosure.
[0039] FIG. 2B illustrates an exemplary system architecture for managing the
10
application deployment across the plurality of platforms, in accordance with an
embodiment of the present disclosure.
[0040] FIG. 3 illustrates an exemplary flow diagram implementing a method for
developing multi-platform applications, in accordance with an embodiment of the
5 present disclosure.
[0041] FIG. 4 illustrates another exemplary flow diagram of a method for
managing the application deployment across the plurality of platforms, in accordance
with an embodiment of the present disclosure.
[0042] FIG. 5 illustrates an exemplary computer system in which or with which
10 the embodiments of the present disclosure may be implemented.
[0043] The foregoing shall be more apparent from the following more detailed
description of the disclosure.
LIST OF REFERENCE NUMERALS
100 – Network Architecture
15 102-1, 102-2…102-N – Users
104-1, 104-2…104-N – User Equipments
106 – Network
108 - System
112 - Centralised Server
20 200A – System Block diagram
202 – Processor(s)
204 – Memory
206 –Interface(s)
208 – Processing engine
25 210 – Database
11
212 – Identification Unit
214 – Processing Unit
200B – System Architecture
216 – Remote Server
5 218-1, 218-2, 218-3, 218-4…218-N – Platforms
220 – Internet
300 – Method Flow Diagram
400 – Method Flow Diagram
500 – Computer System
10 510 – External Storage Device
520 – Bus
530 – Main Memory
540 – Read Only Memory
550 – Mass Storage Device
15 560 – Communication Port
570 – Processor
DETAILED DESCRIPTION
[0044] In the following description, for the purposes of explanation, various
specific details are set forth in order to provide a thorough understanding of
20 embodiments of the present disclosure. It will be apparent, however, that embodiments
of the present disclosure may be practiced without these specific details. Several
features described hereafter can each be used independently of one another or with any
combination of other features. An individual feature may not address any of the
problems discussed above or might address only some of the problems discussed
25 above. Some of the problems discussed above might not be fully addressed by any of
the features described herein. Example embodiments of the present disclosure are
described below, as illustrated in various drawings in which like reference numerals
12
refer to the same parts throughout the different drawings.
[0045] The ensuing description provides exemplary embodiments only, and is not
intended to limit the scope, applicability, or configuration of the disclosure. Rather, the
ensuing description of the exemplary embodiments will provide those skilled in the art
5 with an enabling description for implementing an exemplary embodiment. It should be
understood that various changes may be made in the function and arrangement of
elements without departing from the spirit and scope of the disclosure as set forth.
[0046] Specific details are given in the following description to provide a thorough
understanding of the embodiments. However, it will be understood by one of ordinary
10 skill in the art that the embodiments may be practiced without these specific details.
For example, circuits, systems, networks, processes, and other components may be
shown as components in block diagram form in order not to obscure the embodiments
in unnecessary detail. In other instances, well-known circuits, processes, algorithms,
structures, and techniques may be shown without unnecessary detail in order to avoid
15 obscuring the embodiments.
[0047] Also, it is noted that individual embodiments may be described as a process
that is depicted as a flowchart, a flow diagram, a data flow diagram, a structure
diagram, or a block diagram. Although a flowchart may describe the operations as a
sequential process, many of the operations can be performed in parallel or concurrently.
20 In addition, the order of the operations may be re-arranged. A process is terminated
when its operations are completed but could have additional steps not included in a
figure. A process may correspond to a method, a function, a procedure, a subroutine, a
subprogram, etc. When a process corresponds to a function, its termination can
correspond to a return of the function to the calling function or the main function.
25 [0048] The word “exemplary” and/or “demonstrative” is used herein to mean
serving as an example, instance, or illustration. For the avoidance of doubt, the subject
13
matter disclosed herein is not limited by such examples. In addition, any aspect or
design described herein as “exemplary” and/or “demonstrative” is not necessarily to be
construed as preferred or advantageous over other aspects or designs, nor is it meant to
preclude equivalent exemplary structures and techniques known to those of ordinary
5 skill in the art. Furthermore, to the extent that the terms “includes,” “has,” “contains,”
and other similar words are used in either the detailed description or the claims, such
terms are intended to be inclusive like the term “comprising” as an open transition word
without precluding any additional or other elements.
[0049] Reference throughout this specification to “one embodiment” or “an
10 embodiment” or “an instance” or “one instance” means that a particular feature,
structure, or characteristic described in connection with the embodiment is included in
at least one embodiment of the present disclosure. Thus, the appearances of the phrases
“in one embodiment” or “in an embodiment” in various places throughout this
specification are not necessarily all referring to the same embodiment. Furthermore,
15 the particular features, structures, or characteristics may be combined in any suitable
manner in one or more embodiments.
[0050] The terminology used herein is to describe particular embodiments only
and is not intended to be limiting the disclosure. As used herein, the singular forms “a”,
“an”, and “the” are intended to include the plural forms as well, unless the context
20 indicates otherwise. It will be further understood that the terms “comprises” and/or
“comprising,” when used in this specification, specify the presence of stated features,
integers, steps, operations, elements, and/or components, but do not preclude the
presence or addition of one or more other features, integers, steps, operations, elements,
components, and/or groups thereof. As used herein, the term “and/or” includes any
25 combinations of one or more of the associated listed items. It should be noted that the
terms “mobile device”, “user equipment”, “user device”, “communication device”,
“device” and similar terms are used interchangeably for the purpose of describing the
14
invention. These terms are not intended to limit the scope of the invention or imply any
specific functionality or limitations on the described embodiments. The use of these
terms is solely for convenience and clarity of description. The invention is not limited
to any particular type of device or equipment, and it should be understood that other
5 equivalent terms or variations thereof may be used interchangeably without departing
from the scope of the invention as defined herein.
[0051] While considerable emphasis has been placed herein on the components
and component parts of the preferred embodiments, it will be appreciated that many
embodiments can be made and that many changes can be made in the preferred
10 embodiments without departing from the principles of the disclosure. These and other
changes in the preferred embodiment, as well as other embodiments of the disclosure,
will be apparent to those skilled in the art from the disclosure herein, whereby it is to
be distinctly understood that the foregoing descriptive matter is to be interpreted merely
as illustrative of the disclosure and not as a limitation.
15 [0052] The present invention discloses a method and a system for managing
application deployment across multiple platforms. Code is written using a single
codebase and deployed across multiple target platforms. The single codebase (i.e.,
unified codebase) refers to a unified set of source code used to build applications that
run on multiple platforms (such as iOS, Android, web, desktop etc.) in cross-platform
20 development. The single codebase ensures a consistent user experience across multiple
platforms (i.e., the users get the same features, design, and functionality regardless of
devices or operating systems). The application's functionality and data are exposed
through a standardized interface, allowing other applications or services to interact.
The functions or features of the application that are to be exposed via an application
25 programming interface (API), along with the API protocol to be used, are determined.
An authentication (i.e., ensuring that users are who they claim to be) and an
authorization (i.e., what actions users are allowed to perform) are implemented as
15
security measures. Developers reuse a substantial portion of the code across different
platforms. This minimizes redundancy and improves code efficiency.
[0053] Hereinafter, exemplary embodiments of the present disclosure will be
described with reference to the accompanying drawings.
5 [0054] The various embodiments throughout the disclosure will be explained in
more detail with reference to FIGs. 1-5.
[0055] FIG. 1 illustrates an exemplary network architecture (100) for
implementing a system (108) for managing an application deployment across a
plurality of platforms, in accordance with an embodiment of the present disclosure.
10 [0056] As illustrated in FIG. 1, one or more computing devices (104-1, 104-
2…104-N) may be connected to a disclosed system (108) through a network (106). A
person of ordinary skill in the art will understand that one or more computing devices
(104-1, 104-2…104-N) may be collectively referred to as computing devices (104) and
individually referred to as computing devices (104). One or more users (102-1, 102-
15 2…102-N) may provide one or more requests to the system (108). A person of ordinary
skill in the art will understand that one or more users (102-1, 102-2…102-N) may be
collectively referred to as users (102) and individually referred to as users (102).
Further, the computing devices (104) may also be referred to as user equipment (UE)
(104) or as UEs (104) throughout the disclosure.
20 [0057] In an embodiment, the computing device (104) may include, but not be
limited to, a mobile, a laptop, etc. Further, the computing device (104) may include one
or more in-built or externally coupled accessories, including but not limited to, a visual
aid device such as a camera, audio aid, microphone, or keyboard. Furthermore, the
computing device (104) may include a mobile phone, smartphone, virtual reality (VR)
25 devices, augmented reality (AR) devices, a laptop, a general-purpose computer, a
desktop, a personal digital assistant, a tablet computer, and a mainframe computer.
16
Additionally, input devices for receiving input from the user (102), such as a touchpad,
touch-enabled screen, electronic pen, and the like, may be used.
[0058] In an embodiment, the network (106) may include, by way of example but
not limitation, at least a portion of one or more networks having one or more nodes that
5 transmit, receive, forward, generate, buffer, store, route, switch, process, or a
combination thereof, etc. one or more messages, packets, signals, waves, voltage or
current levels, some combination thereof, or so forth. The network (106) may also
include, by way of example but not limitation, one or more of a wireless network, a
wired network, an internet, an intranet, a public network, a private network, a packet10 switched network, a circuit-switched network, an ad hoc network, an infrastructure
network, a Public-Switched Telephone Network (PSTN), a cable network, a cellular
network, a satellite network, a fiber optic network, or some combination thereof.
[0059] In an embodiment, the centralized server (112) is a computing resource that
provides resources, data, services, or functionality to other computers, devices, or users
15 on the network (106). In an example, the centralized server (112) is a central hub that
manages and responds to requests from client computers or devices. The centralized
server (112) can serve various purposes such as hosting websites, storing and managing
data, providing services, facilitating communication between devices, running
applications accessed by multiple users, and more.
20 [0060] In an embodiment, the UE (104) is communicatively coupled with the
system (108) via the network (106). The system (108) may receive a connection request
from the UE (104). The system (108) may send an acknowledgment of the connection
request to the UE (104). The UE (104) may transmit a plurality of signals in response
to the connection request. The system (108) is configured to manage the application
25 deployment across the plurality of platforms (i.e., platforms (218 (1-N)) as shown in
FIG. 2B) (explained in detail in conjunction with FIGs. 2A and 2B).
17
[0061] Although FIG. 1 shows exemplary components of the network architecture
(100), in other embodiments, the network architecture (100) may include fewer
components, different components, differently arranged components, or additional
functional components than depicted in FIG. 1. Additionally, or alternatively, one or
5 more components of the network architecture (100) may perform functions described
as being performed by one or more other components of the network architecture (100).
[0062] FIG. 2A illustrates an exemplary block diagram (200A) of the system (108)
for managing the application deployment across the plurality of platforms, in
accordance with an embodiment of the present disclosure. FIG. 2A is explained with
10 reference to FIG. 1.
[0063] As seen in FIG. 2, the system (108) comprises one or more processor(s)
(202), a memory (204), an interface(s) (206), a processing engine (208), and a database
(210).
[0064] In an embodiment, the system (108) may include one or more processor(s)
15 (202). The one or more processor(s) (202) may be implemented as one or more
microprocessors, microcomputers, microcontrollers, digital signal processors, central
processing units, logic circuitries, and/or any devices that process data based on
operational instructions. Among other capabilities, the one or more processor(s) (202)
may be configured to fetch and execute computer-readable instructions stored in the
20 memory (204) of the system (108). The memory (204) may be configured to store one
or more computer-readable instructions or routines in a non-transitory computer
readable storage medium, which may be fetched and executed to create or share data
packets over a network service. The memory (204) may include any non-transitory
storage device including, for example, volatile memory such as a Random-Access
25 Memory (RAM), or a non-volatile memory such as an Erasable Programmable Read
Only Memory (EPROM), a flash memory, and the like.
18
[0065] In an embodiment, the system (108) may include the interface(s) (206). The
interface(s) (206) may include a variety of interfaces, for example, interfaces for data
input and output devices (I/O), storage devices, and the like. The interface(s) (206) may
facilitate communication through the system (108). The interface(s) (206) may also
5 provide a communication pathway for one or more components of the system (108).
Examples of such components include, but are not limited to, the processing engine
(208) and the database (210).
[0066] In an embodiment, the system (108) may include the processing engine
(208) that may be implemented as a combination of hardware and programming (for
10 example, programmable instructions) to implement one or more functionalities of the
processing engine (208). In examples described herein, such combinations of hardware
and programming may be implemented in several different ways. For example, the
programming for the processing engine (208) may be processor-executable instructions
stored on a non-transitory machine-readable storage medium and the hardware for the
15 processing engine (208) may comprise a processing resource (for example, one or more
processors), to execute such instructions. In the present examples, the machinereadable storage medium may store instructions that, when executed by the processing
resource, implement the processing engine (208). In such examples, the system (108)
may comprise the machine-readable storage medium storing the instructions and the
20 processing resource to execute the instructions, or the machine-readable storage
medium may be separate but accessible to the system (108) and the processing
resource. In other examples, the processing engine (208) may be implemented by
electronic circuitry.
[0067] In an embodiment, the system (108) may include the database (210) that
25 stores data generated as a result of functionalities implemented by any of the
components of the processor (202) or the processing engine (208). In an aspect, the
database (210) may include any computer-readable medium known in the art,
19
including, for example, volatile memory, such as Static Random Access Memory
(SRAM) and Dynamic Random Access Memory (DRAM) and/or nonvolatile memory,
such as Read-Only Memory (ROM), erasable programmable ROM, flash memories,
hard disks, optical disks, and magnetic tapes.
5 [0068] The processing engine (208) comprises an identification unit (212) and a
processing unit (214).
[0069] The identification unit (212) is configured to identify an application
development framework supporting the plurality of platforms (i.e., platforms (218-1 –
218-N) as shown in FIG. 2B) based on one or more attributes associated with each of
10 the plurality of platforms and an application.
[0070] In an aspect, the application is a program for providing specific
functionality to the users. The developer can develop applications that provide various
functionalities. The applications may comprise, but are not limited to, mobile
applications (e.g., messaging application, banking application, etc.), gaming
15 applications (e.g., video games), desktop applications (e.g., document processing
application, media player application, etc.), web applications (e.g., video streaming,
email, social media, etc.), etc.
[0071] In an aspect, the platform refers to the foundational environment on which
software/applications run. The platform provides tools, libraries, and infrastructure to
20 build, deploy, and execute programs.
[0072] The plurality of platforms comprises, but are not limited to, iPhone
operating system (iOS), Android, web, desktop, etc. In an aspect, the iOS platform
is Apple's mobile operating system and software for its handheld devices (e.g., iPhones,
iPads, and iPod Touch). The iOS platform includes the OS, development tools (e.g.,
25 Xcode), services (e.g., iCloud), and the App Store, which provides users with secure
and integrated experience. In an aspect, the Android platform refers to a Linux-based,
20
open-source software stack designed for various devices (e.g., smartphones and
tablets). The Android platform includes an operating system, a user interface, a web
browser, and a suite of pre-installed and downloadable applications. The Android
platform is built upon the Android Open-Source Project (AOSP), allowing for
5 modifications and variation. In an aspect, the web platform is a software application
accessible via a web browser, allowing the users to interact with and manage online
content and services without needing to install any special software. In an aspect, the
desktop platform refers to the operating system and runtime environment that supports
applications designed to run on desktop or laptop computers.
10 [0073] The one or more attributes of the plurality of platforms comprise, but are
not limited to, technical attributes, functional attributes, and non-functional attributes,
etc. Information corresponding to the one or more attributes of the plurality of
platforms is obtained from configuration files of the plurality of platforms.
[0074] The technical attributes refer to attributes that define technology and
15 system capabilities. The technical attributes comprise, but are not limited to, operating
systems (Windows, Linux, macOS, Android, iOS, etc.), programming languages,
frameworks (e.g., Django high-level Python web framework, Spring Boot open-source
Java-based framework, Angular TypeScript-based, front-end web framework, etc.),
libraries, architecture styles, database support, application programming interface
20 (API) support, deployment options, integration tools, etc.
[0075] The functional attributes refer to attributes that describe what the platform
does and how the users interact with the platform. The functional attributes comprise,
but are not limited to, user management (e.g., User registration, login/logout, password
reset, etc.), content sharing (e.g., Uploading and sharing documents, videos, or images,
25 etc.), search (e.g., Full-text search, faceted search, filtered search, etc.), user roles and
permissions (e.g., admin, editor, viewer, guest, etc.), multi-language and regional
support (e.g., Language selection (English, Spanish, Chinese), time zone settings,
21
regional formatting (dates, currency), etc.), integration capabilities (i.e., ability to
connect with external tools such as customer relational management (CRM), enterprise
resource planning (ERP), payment gateways, open authorization), scalability (e.g.,
Ability to add more servers automatically when traffic increases (auto-scaling), etc.),
5 etc.
[0076] The non-functional attributes refer to attributes that determine how well
application/system performs. The non-functional attributes include, but are not limited
to, performance (e.g., Response time, etc.), security (e.g., SSL/TLS encryption, Twofactor authentication (2FA), data encryption at rest, etc.), reliability (e.g., % uptime,
10 failover mechanisms, disaster recovery, etc.), usability (e.g., Intuitive user interface,
accessibility for people with disabilities (e.g., screen reader support)), compliance (e.g.,
payment security compliance, etc.), etc.
[0077] The application development framework refers to a set of tools and
libraries that help developers build applications faster and more efficiently. The
15 application development framework provides a structure for organizing code and often
includes reusable components for UI, data handling, security, etc. The application
development framework is also referred to as a cross-platform development
framework. The application development framework may be, but is not limited to,
React Native, Xamarin, Flutter, Native Android, Native iOS, etc.
20 [0078] The identification unit (212) identifies the application development
framework from a plurality of application development frameworks to support the
plurality of platforms (e.g., iOS, Android, desktop, web, etc.) based on the attributes
(e.g., operating systems, programming languages, integration, scalability, etc.) of each
platform and the application. For instance, the identification unit (212) may identify
25 ‘Flutter’ as the application development framework from a plurality of frameworks
(e.g., Flutter, React Native, Xamarin, Ionic) to support a plurality of platforms
including iOS, Android, and web. The selection is based on the attributes of each
22
platform and the application, such as: Operating Systems: Need to support both iOS
and Android; Programming Languages: Preference for Dart (used by Flutter); and
Integration: Ability to integrate with REST APIs and Firebase. The processing unit
(214) is communicatively coupled to the identification unit (212). The processing unit
5 (214) is configured to receive the identified application development framework from
the identification unit (212). Upon receiving the identified application development
framework, the processing unit (214) is configured to create a unified codebase
corresponding to the application associated with each of the plurality of platforms using
the identified application development framework. In an aspect, the unified codebase
10 is also referred to as a shared codebase. In an aspect, the processing unit (214) creates
the unified codebase corresponding to each platform using the identified application
development framework (e.g., cross platform development framework) by performing
steps such as designing a user interface, writing code, performing testing to ensure
performance and usability, etc. The developers create the unified codebase in a unified
15 development environment using a single set of programming languages, tools, and
libraries. The unified development environment eliminates platform-specific
complexities. For example, upon receiving the identified application development
framework (e.g., Flutter), the processing unit (214) is configured to create a unified
codebase for the application that targets iOS, Android, and Web platforms. For
20 example, the processing unit (214) generates a single Dart-based codebase where the
user interface components are built once and rendered appropriately on both mobile
and web. In aspects, the Dart-based codebase may cover platform-specific
functionalities (e.g., camera access, notifications) using Flutter’s platform channels.
Further, the Dart-based codebase applies responsive design principles to adjust layouts
25 across different screen size (e.g., phones, tablets, desktops, etc.). As a result, the same
codebase can be compiled into a native iOS app, a native Android app, and a web
application without requiring entirely separate development efforts for each platform.
[0079] In an aspect, the unified codebase is a core logic of the application that
23
comprises business logic, data models, and non-platform-specific components. The
core logic is written by the developers. The core logic of an application refers to the
functionality and algorithms that drive its operation. The core logic dictates how data
is processed, manipulated, and managed to fulfill the application's purpose. The core
5 logic interacts with various application parts, such as the user interface, databases, and
external services, ensuring the application performs the desired tasks correctly and
efficiently. The unified codebase represents a majority of the application's
functionality.
[0080] To create the unified codebase, the processing unit (214) is configured to
10 generate a standardized Application Programming Interface (API) corresponding to
one or more of a plurality of application functionalities associated with the application.
The standard API corresponding to the plurality of application functionalities is
generated by performing steps such as determining application functionality of the
application, defining endpoints (e.g., developers to interact with the API), defining data
15 structures (i.e., to determine how data will be exchanged between the API and the users
(e.g., clients)), selection of HTTP method (i.e., the instructions that the user (i.e., client)
sends to a server to specify the action it wants to perform), implementation of security
measures, and error handling, etc.
[0081] The plurality of application functionalities comprises, but is not limited to,
20 user profile management, data storage and retrieval, notifications (e.g., push, in-app,
email, short messaging service (SMS), media management (e.g., video/audio
uploading, editing, streaming, etc.), search and filter, communication (e.g., chat,
message, voice/video call, etc.), payment (e.g., in-app purchase, subscription, thirdparty gateways, etc.), location-based services, data analytics, task and workflow
25 management, security features (e.g., biometric, two-factor authentication, data
encryption, access control, etc.), content creation and sharing, customization,
integration with external services, file management, user feedback, etc.
24
[0082] In an aspect, the processing unit (214) also generates the standard API
corresponding to the plurality of application functionalities using the identified
application development framework's components and style. The components of the
application development framework comprise, but are not limited to, text, button, label,
5 list entry, card, label, plugin, etc. The style of the application development framework
comprises, but is not limited to padding, font size, background color, margin, text color,
etc. The functionality (e.g., task creation, user authentication, notifications, etc.) and
data of the application are exposed through the standardized API with which other
applications or services interact. Also, the API protocol to be used is determined using
10 the framework's components and styles. The API protocol comprises, but is not limited
to, a Hypertext Transfer Protocol / Secure (HTTP/HTTPS), Representational State
Transfer (REST), etc.
[0083] The processing unit (214) is further configured to implement an
authentication mechanism corresponding to the standardized API generated for one or
15 more of the plurality of application functionalities.
[0084] In an aspect, the authentication mechanism refers to a security process used
to verify the user's identity when trying to access the application. The authentication
mechanism comprises, but is not limited to, username and password, two-factor
authentication, token, open authentication (OAuth), biometric, password less Auth
20 (e.g., one-time password (OTP)), etc. The authentication and authorization mechanism
corresponding to the standardized API is the process used to verify and authorize the
users or clients making requests to the API, ensuring that only authenticated entities
can access protected resources or perform sensitive operations. The processing unit
(214) applies the authentication mechanism corresponding to the standardized API to
25 perform authentication (i.e., ensuring that users are who they claim to be) and
authorization (i.e., what actions users are allowed to perform) as security measures.
[0085] After creating the unified codebase, the processing unit (214) is configured
25
to transform the created unified codebase into a platform-supported codebase
associated with each of the plurality of platforms using the identified application
development framework. Transforming the unified codebase into the platformsupported codebase refers to a process of modifying, adapting, or restructuring the
5 application's unified code so that the unified code runs correctly and efficiently on a
specific target platform (e.g., Android, iOS, web, or desktop) to meet the platform’s
technical, design, and performance requirements.
[0086] Transforming the unified codebase into the platform-supported codebase
comprises steps such as identifying the target platform, modularizing the unified
10 codebase by splitting the unified codebase into core logic (e.g., business logic, data
models, etc.) and platform-specific modules (e.g., user interface (UI), file access,
sensor, etc.), replacing the generic libraries with platform-supported ones, testing the
code on the target platform, optimizing performance of the target platform, and
handling platform-specific errors.
15 [0087] The processing unit (214) is further configured to deploy the transformed
platform-supported codebase to a distribution channel associated with each of the
plurality of platforms.
[0088] In an aspect, the distribution channel associated with each platform refers
to a channel or specific way the application is delivered, published, and made available
20 to end users (i.e., customers who are downloading/using the application) on the target
platform (e.g., Android, iOS, web, or desktop). The distribution channel comprises, but
is not limited to, play store, app store, web hosting platform, direct download, cloud
platform, internal repositories, installers, etc.
[0089] The transformed platform-supported codebase associated with the
25 application is deployed in the distribution channel by performing steps such as packing
the transformed platform-supported codebase (e.g., Android Application Package
26
(APK) for Android, .dmg for macOS, .exe for Windows), configuring the deployment
by using platform-specific deployment tools or services, deploying the codebase to the
distributed channel (e.g., play store, app store, web hosting platform, direct download,
cloud platform, internal repositories, installers, etc.), and testing and monitoring, etc.
5 [0090] In an aspect, a compiled application (i.e., the transformed platformsupported codebase) is deployed to a corresponding distribution channel (e.g., app
store) for each platform. The developers follow the guidelines and procedures provided
by each platform for submission and approval.
[0091] The processing unit (214) is further configured to generate a platform10 specific code corresponding to the application based on one or more platform
functionalities associated with the platform using the identified application
development framework.
[0092] In an aspect, the platform-specific code is generated to address differences
in UI design, device features, or any other platform-specific requirements.
15 [0093] In an aspect, the platform functionalities refer to the set of core services,
capabilities, and APIs provided by a platform (e.g., Android, iOS, Web, Windows, etc.)
that the application uses to perform specific tasks, access hardware, or integrate with
the platform’s system. The Android and iOS platform functionalities comprise, but are
not limited to, camera, media access, location, push notification, contact, calendar,
20 sensors, in-app purchase/payment, authentication, app permissions, etc. The web
platform functionalities comprise, but are not limited to, document object model
(DOM), user interface (UI) rendering, storage (e.g., local, session), cookies,
authentication, web sockets, HTTP Requests, location, media access, notifications,
offline support, caching, etc. The desktop platform functionalities comprise, but are not
25 limited to, file system access, window & UI management, clipboard access,
notifications, system integration, background services, task scheduling, installer, auto
27
update, etc.
[0094] In an aspect, generation of platform-specific code corresponding to the
application based on the platform functionalities comprises steps such as identifying
platform-specific needs, separating code for each platform, and applying platform5 specific implementations. The unified code is compiled and packaged separately for
each target platform. The application development framework performs translation of
the unified code and platform-specific code into native code for each platform.
[0095] After generating the platform-specifc code, the processing unit (214) is
further configured to integrate the platform-specific code with the unified codebase
10 associated with the application. Integration of the platform-specific code with the
unified codebase comprises steps such as selecting a platform-supported framework,
selection of business logic (e.g., data models, state management, API requests,
authentication logic, etc.), creating platform-specific implementations (e.g., UI
components, access control, notifications, sensors or device-specific features, etc.).
15 [0096] In an embodiment, the application is rendered to an end user (e.g.,
customer) based on one or more native components associated with a platform of the
plurality of platforms supported by a user device of the end user. In an aspect, the native
components refer to user interface (UI) elements (e.g., buttons, text views, images,
sliders, views, navigation bars, etc.) that are built directly into the operating system
20 (iOS or Android). In an aspect, the application development framework (e.g., crossplatform development framework) renders the user interface of the application using
the native components. When a significant portion of the code is shared, the application
appears as a native app on each platform due to platform-specific rendering.
[0097] Furthermore, the application development framework provides access to
25 native APIs and features of each platform. This allows developers to incorporate
platform-specific functionality and take advantage of device capabilities.
28
[0098] In an aspect, the native API refers to an API built into the application (or
operating system) to allow direct communication between the application or the native
component without relying on external tools.
[0099] The application development framework (i.e., cross-platform development
5 framework) provides an abstraction layer that handles the communication between the
unified code and the underlying native components of each platform. The abstraction
layer ensures that the application can interact with platform-specific features
seamlessly.
[00100] In an aspect, the processing unit (214) is configured to test functioning of
10 the application across each of the plurality of platforms using the application
development framework (i.e., cross-platform development framework) based on one
or more testing tools. The application is tested to ensure that the application works
consistently and correctly across each platform using the application development
framework. The testing of the application comprises, but is not limited to, functional
15 testing, user interface (UI) testing, performance testing, security testing, integration
testing, usability testing, etc.
[00101] In an aspect, the processing unit (214) is further configured to perform
testing of the unified codebase, the platform-supported codebase, and the platformspecific code using testing tools and the application development frameworks. Testing
20 ensures that the application functions correctly on each platform and that the user
experience is consistent.
[00102] In an aspect, the processing unit (214) is further configured to identify and
fix issues by using debugging and profiling tools provided by the application
development framework (e.g., cross-platform development framework). Furthermore,
25 the developers use platform-specific debugging tools for identification of platformspecific issues.
29
[00103] The processing unit (214) is further configured to modify the unified
codebase associated with the application based on one or more parameters. The one or
more parameters comprise a new functionality, an error, and a new security protocol.
The unified codebase is modified to accommodate the new functionality, error, new
5 security protocol, and configuration changes, etc. For example, the new functionality
comprises, but is not limited, adding support for multiple languages, offline mode, new
user roles/permissions, etc. For example, the error comprises, but is not limited to, user
interface (UI) glitches, data loading errors, security vulnerabilities, and compatibility
errors, etc.
10 [00104] In an aspect, the security protocol feature includes user authentication
features (e.g., fingerprint, face ID, security code such as personal identification number
(PIN), etc.). The security protocol feature further comprises user data-related access
permission (e.g., access to location, access to camera, access for library, etc.). The
security protocol may also include data encryption techniques used for the application.
15 [00105] After modifying the unified codebase, the processing unit (214) is further
configured to update the platform-supported codebase associated with each of the
plurality of platforms based on the modified unified codebase using the application
development framework. The platform-supported codebase associated with each
platform is also updated based on the modified unified codebase. Upon detecting
20 application updates or maintenance requirements, the developers make changes in the
unified codebase. The application development framework handles the compilation,
packaging, and deployment processes corresponding to updates or maintenance for
each platform.
[00106] Although FIG. 2A shows exemplary components of the system (108), in
25 other embodiments, the system (108) may include fewer components, different
components, differently arranged components, or additional functional components
than depicted in FIG. 2A. Additionally, or alternatively, one or more components of
30
the system (108) may perform functions described as being performed by one or more
other components of the system (108).
[00107] FIG. 2B illustrates an exemplary system architecture (200B) for managing
the application deployment across the plurality of platforms (218), in accordance with
5 an embodiment of the present disclosure.
[00108] FIG. 2B, with reference to FIG. 1 and FIG. 2A, illustrates system
architecture (200B) for managing the application deployment across the plurality of
platforms (218).
[00109] The system architecture (200B) comprises the memory (204) and the
10 database (210), a remote server (216), the plurality of platform (218-1, 218-2, 218-3,
218-4, …218-N) and an internet (220). A person of ordinary skill in the art will
understand that the plurality of platforms (218-1, 218-2…218-N) may be collectively
referred to as platforms (218) and individually referred to as a platform (218).
[00110] Referring to FIG. 2B, in an embodiment, the system architecture (200B)
15 may include a non-memory (e.g., hard disk drive, solid-state drive) within the system
(108) that may be configured to store the unified codebase of the platform-independent
application. This codebase is independent of the platform (218) and may be reused
across various platforms. The codebase may include business logic, data models, nonplatform-specific UI components.
20 [00111] The business logic may be a logic of the application, defining how data is
processed, and functionalities are implemented. The business logic is platformindependent and written in a language suitable for the cross-platform development
framework (e.g., Java, Kotlin).
[00112] The data models may be representations of the data used by the application.
25 The data models define the structure and organization of the data, independent of how
31
it is stored or accessed on different platforms.
[00113] The non-platform-specific UI components may be reusable UI elements
that are used to build the application's user interface across different platforms. nonplatform-specific UI components include generic components (e.g., buttons, text fields,
5 or lists). The platform-specific UI elements include native navigation bars.
[00114] In an aspect, the memory (204) may be part of a local machine where the
development happens or located on a remote server (216) as part of a cloud-based
development environment.
[00115] In an aspect, a specific type of storage technology may be used instead of
10 memory (204) depending on the implementation.
[00116] In an embodiment, the platform-independent application development
refers to creating applications using a single programming language or platform that
may be utilized across multiple platforms without creating separate versions for each
platform. The platform (218) may encompass various types of electronic devices with
15 standard designs compatible with specific operating systems. Examples of platforms
(218) include operating systems like Linux, iOS, Android, Windows Phone-based OS,
and Blackberry-based OS. For instance, an application developed in a platformindependent language may be deployed on both iOS and Android platforms without
necessitating the creation of native versions specifically for each platform (218).
20 [00117] In an embodiment, the platform (218-1) may be configured for the iOS
operating system. This refers to devices running Apple’s iOS operating system, such
as iPhones, iPads, and iPod Touches. The system (108) supports development for
applications that run specifically on iOS devices. For example, in an embodiment, the
computing device (104-N) (as shown in FIG. 1) may be an iPad. The platform (218-1)
25 may correspond to the computing device (104-N).
32
[00118] In an embodiment, the platform (218-2) may be configured for the Android
operating system. This refers to devices running Google’s Android operating system,
including smartphones and tablets from various manufacturers. The system would
accommodate development for applications that function on Android devices. For
5 example, in an embodiment, the computing device (104-1) (as shown in FIG. 1) may
be an android device. The platform (218-1) may correspond to the computing device
(104-1).
[00119] In an embodiment, the platform (218-3) may be configured for web
environments. This signifies web browsers on various devices and operating systems.
10 The system would enable development for web applications that run within a web
browser, accessible through the internet.
[00120] In an embodiment, the platform (218-4) may be configured for desktop
(where n represents any number of supported desktop environments). This signifies
desktop computers running various operating systems like Windows, macOS, or Linux.
15 For example, in an embodiment, the computing device (104-2) (as shown in FIG. 1)
may be a desktop computing device. The platform (218-1) may correspond to the
computing device (104-2).
[00121] In an embodiment, the value of "N" for the platform (218-N) can be any
number depending on the specific desktop environments the system supports for
20 application development (e.g., N=2 for Windows and macOS).
[00122] In an embodiment, the platforms (218-1, 218-2…218-N) may all be
connected to the internet (220). In an aspect, the internet (220) is a part of the network
(106).
[00123] In an embodiment, the remote server (216) plays a central role in the system
25 (108) for platform-independent application development. The remote server (216) may
be a repository for hosting the developed application and its associated Application
33
Programming Interface (API). This means that the core application code and the API
logic reside on the server and are accessible to client applications on one or more
platforms (218).
[00124] In an aspect, the remote server (216) may facilitate communication
5 between the client applications and the API. When a client application running on a
specific platform (218-2) (e.g., an Android phone) needs to access functionalities or
data exposed through the API, the platform (218-2) sends requests to the remote server.
The server then processes these requests, interacts with the application logic and
database as needed, and sends responses to the client application.
10 [00125] In an aspect, the remote server (216) may provide a central location for
managing the application and APIs. Updates, bug fixes, or security patches may be
deployed on the remote server (216), automatically affecting all client applications
accessing the remote server (216).
[00126] In an embodiment, the database (210) may be connected to the remote
15 server (216). The database (210) stores the application's data securely. The remote
server (216) manages access to this database (210), ensuring that client applications
and the API can interact with the data appropriately. This may involve functionalities
like data retrieval, updates, and deletion based on user actions within the client
application.
20 [00127] Although FIG. 2B shows exemplary components of the system architecture
(200B), in other embodiments, the system architecture (200B) may include fewer
components, different components, differently arranged components, or additional
functional components than depicted in FIG. 2B. Additionally, or alternatively, one or
more components of the system may perform functions described as being performed
25 by one or more other components of the system 108.
[00128] FIG. 3 illustrates an exemplary flow diagram implementing a method (300)
34
for developing multi-platform applications, in accordance with an embodiment of the
present disclosure.
[00129] FIG. 3, with reference to FIGs. 1-2B, illustrates the method (300) for
developing the multi-platform applications.
5 [00130] At step (302), the method (300) includes establishing a unified codebase of
an application for the platform (218) to ensure that the application’s core logic is
centralized and independent of the target platform. This unified codebase may include
business logic, data models, and non-platform-specific user interface (UI) components,
facilitating efficient development and code reuse across multiple platforms. Further,
10 establishing a unified codebase promotes efficient development by allowing
developers to write the core logic once and reuse the unified codebase for various
platforms.
[00131] At step (304), the method (300) includes employing a cross-platform
development framework supporting the platform (218) and integrating platform15 specific code within the framework to adapt to the platform's requirements. The method
(300) may utilize the platform-specific code within the chosen framework.
[00132] The platform-specific code includes platform-specific UI components and
platform-specific application programming interfaces (APIs).
[00133] The platform-specific UI components (e.g., buttons, navigation bars)
20 mimic the native appearance and behavior of the UI elements on the target platform.
[00134] The platform-specific code interacts with features and functionalities
offered by the underlying platform's APIs (e.g., camera, GPS).
[00135] In an aspect, integrating a platform-specific code allows the application to
adapt to the target platform's requirements, providing a native user experience while
35
maintaining a single codebase for core functionalities.
[00136] At step (306), the method (300) includes implementing a standardized
Application Programming Interface (API) based on the set of requirements for the
platform, allowing for the exposure of the application's functionalities and data to
5 external applications or services. This standardized API facilitates seamless
communication and integration with external systems.
[00137] At step (308), the method (300) includes implementing authentication
within the API to ensure secure access and verifying the identity of users attempting to
access the API. This security measure helps protect sensitive data and functionalities
10 exposed through the API, enhancing the application's overall security.
[00138] At step (310), the method (300) includes generating the application for
execution on each platform (218) using the cross-platform development framework,
compiling, and packaging the codebase into executable packages compatible with each
target platform. This ensures that the application is properly prepared for deployment
15 across multiple platforms.
[00139] At step (312), the method (300) includes installing the generated
application to a relevant app store or distribution channel (e.g., play store, web hosting
platform, installers, etc.), making the application available for download and
installation by users on their respective platforms. This step ensures the application
20 reaches intended audience through popular distribution channels.
[00140] At step (314), the method (300) includes maintaining and updating the
application by modifying the unified codebase, allowing seamless updates across all
platforms. This ensures that the application remains updated with the latest features,
bug fixes, and security patches, providing users with consistently improved experience
25 over time.
36
[00141] FIG. 4 illustrates another exemplary flow diagram of a method (400) for
managing the application deployment across the plurality of platforms (218), in
accordance with an embodiment of the present disclosure.
[00142] FIG. 4, with reference to FIGs. 1-3, illustrates the method (400) for
5 managing the application deployment across the plurality of platforms (218).
[00143] At step (402), the method (400) identifying (402), by an identification unit
(212), an application development framework supporting the plurality of platforms
(218) based on one or more attributes associated with each of the plurality of platforms
(218) and an application. In an embodiment, the plurality of platforms comprises, but
10 is not limited to, iPhone operating system (iOS), Android, web, desktop, etc. The
identification unit (212) identifies the application development framework to support
the plurality of platforms (e.g., iOS, Android, desktop, web, etc.) based on the attributes
(e.g., operating systems, programming languages, integration, scalability, etc.) of each
platform and the application.
15 [00144] At step (404), the method (400) includes creating, by a processing unit
(214), a unified codebase corresponding to the application associated with each of the
plurality of platforms (218) using the identified application development framework.
To create the unified codebase, this step further comprises generating a standardized
Application Programming Interface (API) corresponding to one or more of a plurality
20 of application functionalities associated with the application and implementing an
authentication mechanism corresponding to the standardized API generated for the
plurality of application functionalities associated with the application.
[00145] The processing unit (214) creates the unified codebase corresponding to
each platform using the identified application development framework (e.g., cross
25 platform development framework). The unified codebase is created in a unified
development environment using a single set of programming languages, tools, and
37
libraries. The unified codebase (e.g., single codebase) is created by performing steps
such as designing user interface components, writing code, performing testing to
ensure performance and usability, etc. The unified development environment
eliminates platform-specific complexities.
5 [00146] The processing unit (214) generates the standard API corresponding to the
plurality of application functionalities by performing steps such as determining
application functionality of the application, defining endpoints (e.g., developers to
interact with the API), defining data structures (i.e., to determine how data will be
exchanged between the API and the users (e.g., clients)), selection of HTTP method
10 (i.e., the instructions that the user (i.e., client) sends to a server to specify the action it
wants to perform), implementation of security measures, and error handling, etc.
[00147] The processing unit (214) further generates the standard API corresponding
to the plurality of application functionalities using the application development
framework's components and style. The functionality and data of the application are
15 exposed through the standardized API, with which other applications or services
interact. Also, the API protocol to be used is determined using the framework's
components and styles.
[00148] The processing unit (214) is further configured to implement an
authentication mechanism corresponding to the standardized API generated for the one
20 or more of the plurality of application functionalities associated with the application.
To implement the authentication mechanism, performing steps, but are not limited to,
selection of an authentication method (e.g., username and password, token-based
authentication), creation of user authentication endpoints, verification of user
credentials against stored user data, perform role or permission checks if necessary,
25 and ensure all relevant security considerations are addressed. The processing unit (214)
applies the authentication mechanism corresponding to the standardized API to
perform authentication (i.e., ensuring that users are who they claim to be) and
38
authorization (i.e., what actions users are allowed to perform) as security measures.
[00149] At step (406), the method (400) includes transforming, by the processing
unit (214), the created unified codebase corresponding to the application into a
platform-supported codebase associated with each of the plurality of platforms (218)
5 using the identified application development framework. In an aspect, transforming the
created unified codebase into the platform-supported codebase comprises steps such as
identifying the target platform, modularizing the unified codebase by splitting the
unified codebase into core logic (e.g., business logic, data models, etc.) and platformspecific modules (e.g., user interface (UI), file access, sensor, etc.), replacing the
10 generic libraries with platform-supported ones, testing the code on the target platform,
optimizing performance of the target platform, and handling platform-specific errors.
Further, the created unified codebase is transformed into the platform-supported
codebase through a process of adapting the code to specific platform needs while
maintaining the unified codebase (e.g., shared codebase). This involves platform15 specific code that handles user interface (UI) elements, platform application
programming interface (APIs), and device-specific functionalities, ensuring the
application performs correctly on each target platform. The processing unit (214)
transforms the unified codebase into the platform-supported codebase to modify, adapt,
or restructure the application's unified code so that the platform-supported codebase
20 runs correctly and efficiently on the target platform (e.g., Android, iOS, web, or
desktop) to meet the platform’s technical, design, and performance requirements.
[00150] At step (408), the method (400) includes deploying, by the processing unit
(214), the transformed platform-supported codebase to in a distribution channel
associated with each of the plurality of platforms (218). The transformed platform25 supported codebase associated with the application is deployed in the distribution
channel (e.g., play store, app store, web hosting platform, direct download, cloud
platform, internal repositories, installers, etc.). The transformed platform-supported
39
codebase associated with the application is deployed in the distribution channel by
performing steps such as packing the transformed platform-supported codebase (e.g.,
Android Application Package (APK) for Android, .dmg for macOS, .exe for
Windows), configuring the deployment by using platform-specific deployment tools or
5 services, and deploying the codebase to the distributed channel, etc.
[00151] The method (400) further comprises generating, by the processing unit
(214), a platform-specific code corresponding to the application based on one or more
platform functionalities associated with the platform using the identified application
development framework and integrating, by the processing unit (214), the platform10 specific code with the unified codebase associated with the application. In an aspect,
generation of platform-specific code corresponding to the application based on the
platform functionalities comprises steps such as identifying platform-specific needs,
separating code for each platform, and applying platform-specific implementations.
The unified code is compiled and packaged separately for each target platform. The
15 application development framework performs translation of the unified code and
platform-specific code into native code for each platform. Integration of the platformspecific code with the unified codebase comprises steps such as selecting a platformsupported framework, selection of business logic (e.g., data models, state management,
API requests, authentication logic, etc.), creating platform-specific implementations
20 (e.g., UI components, access control, notifications, sensors or device-specific features,
etc.). The platform-specific code is generated to address differences in UI design,
device features, or any other platform-specific requirements. The unified code is
compiled and packaged separately for each target platform. The identified application
development framework performs translation of the unified code and platform-specific
25 code into native code for each platform.
[00152] In an aspect, the application is rendered to an end user (e.g., customer)
based on one or more native components associated with a platform of the plurality of
40
platforms (218) supported by a user device of the end user (for example, in an aspect,
user device (104) of the user (102)). The native components refer to user interface (UI)
elements (e.g., buttons, text views, images, sliders, views, navigation bars, etc.).
[00153] The method (400) further comprises modifying, by the processing unit
5 (214), the unified codebase associated with the application based on one or more
parameters. The one or more parameters comprise a new functionality, an error, and a
new security protocol. The unified codebase is modified to accommodate the new
functionality, error, new security protocol, and configuration changes, etc. In an aspect,
modification of the unified codebase comprises steps, but are not limited to,
10 understanding the changes required for each modification, planning the
implementation by identifying necessary code modifications, executing the changes
within a version control system, thoroughly testing the changes, and reviewing the
code, etc.
[00154] The method (400) further comprises updating, by the processing unit (214),
15 the platform-supported codebase associated with each of the plurality of platforms
(218) based on the modified unified codebase using the identified application
development framework. Upon detecting application updates or maintenance
requirements, the unified codebase is updated. The platform-supported codebase is
updated based on updated unified codebase. The application development framework
20 handles the compilation, packaging, and deployment processes corresponding to
updates or maintenance for each platform.
[00155] FIG. 5 illustrates an exemplary computer system (500) in which or with
which the embodiments of the present disclosure may be implemented.
[00156] As shown in FIG. 5, the computer system (500) may include an external
25 storage device (510), a bus (520), a main memory (530), a read-only memory (540), a
mass storage device (550), a communication port(s) (560), and a processor (570). A
41
person skilled in the art will appreciate that the computer system (500) may include
more than one processor and communication ports. The processor (570) may include
various modules associated with embodiments of the present disclosure. The
communication port(s) (560) may be any of an RS-232 port for use with a modem5 based dialup connection, a 10/100 Ethernet port, a Gigabit or 10 Gigabit port using
copper or fiber, a serial port, a parallel port, or other existing or future ports. The
communication ports(s) (560) may be chosen depending on a network, such as a Local
Area Network (LAN), Wide Area Network (WAN), or any network to which the
computer system (500) connects.
10 [00157] In an embodiment, the main memory (530) may be Random Access
Memory (RAM), or any other dynamic storage device commonly known in the art. The
read-only memory (540) may be any static storage device(s) e.g., but not limited to, a
Programmable Read Only Memory (PROM) chip for storing static information e.g.,
start-up or basic input/output system (BIOS) instructions for the processor (570). The
15 mass storage device (550) may be any current or future mass storage solution, which
can be used to store information and/or instructions. Exemplary mass storage solutions
include, but are not limited to, Parallel Advanced Technology Attachment (PATA) or
Serial Advanced Technology Attachment (SATA) hard disk drives or solid-state drives
(internal or external, e.g., having Universal Serial Bus (USB) and/or Firewire
20 interfaces).
[00158] In an embodiment, the bus (520) may communicatively couple the
processor(s) (570) with the other memory, storage, and communication blocks. The
bus (520) may be, e.g. a Peripheral Component Interconnect (PCI)/PCI Extended (PCIX) bus, Small Computer System Interface (SCSI), Universal Serial Bus (USB), or the
25 like, for connecting expansion cards, drives, and other subsystems as well as other
buses, such a front side bus (FSB), which connects the processor (570) to the computer
system (500).
42
[00159] In another embodiment, operator, and administrative interfaces, e.g., a
display, keyboard, and cursor control device may also be coupled to the bus (520) to
support direct operator interaction with the computer system (500). Other operator and
administrative interfaces can be provided through network connections connected
5 through the communication port(s) (560). Components described above are meant only
to exemplify various possibilities. In no way should the aforementioned exemplary
computer system (500) limit the scope of the present disclosure.
[00160] The exemplary computer system (500) is configured to execute a computer
program product comprising a non-transitory computer-readable medium comprising
10 instructions that, when executed by one or more processors, cause the one or more
processors to perform a method for managing an application deployment across a
plurality of platforms is described. The method comprises identifying, by an
identification unit, an application development framework supporting the plurality of
platforms based on one or more attributes associated with each of the plurality of
15 platforms and an application and creating, by a processing unit, a unified codebase
corresponding to the application associated with each of the plurality of platforms using
the identified application development framework. The method comprises
transforming, by the processing unit, the unified codebase created for the application
into a platform-supported codebase associated with each of the plurality of platforms
20 using the identified application development framework and deploying, by the
processing unit, the transformed platform-supported codebase to a distribution channel
associated with each of the plurality of platforms.
[00161] The present disclosure provides technical advancements related to the
management of an application deployment across multiple platforms. The
25 advancement addresses the limitations of existing solutions by identifying an
application development framework supporting multiple platforms based on one or
more attributes. A unified codebase corresponding to the application associated with
43
each platform is created using the application development framework. The unified
codebase created for the application is transformed into a platform-supported codebase
associated with each platform. The transformed platform-supported codebase
associated with the application is deployed in a distribution channel associated with
5 each platform. The unified code is written once and deployed across multiple
platforms. This saves time compared to developing separate code for each platform.
The unified codebase ensures consistent user experience across different platforms.
The users experience the same features, design, and functionality, regardless of their
device or operating system. Maintenance of a single codebase is more straightforward
10 than managing multiple codebases. Reuse of a substantial portion of the unified code
across different platforms minimizes redundancy and improves code efficiency.
[00162] While the foregoing describes various embodiments of the invention, other
and further embodiments of the invention may be devised without departing from the
basic scope thereof. The scope of the invention is determined by the claims that follow.
15 The invention is not limited to the described embodiments, versions or examples,
which are included to enable a person having ordinary skill in the art to make and use
the invention when combined with information and knowledge available to the person
having ordinary skill in the art.
ADVANTAGES OF THE PRESENT DISCLOSURE
20 [00163] The present disclosure described herein above has several technical
advantages including, but not limited to, the realization of the system and the method
that:
eliminates the need to duplicate development efforts for each platform,
significantly reducing development time and resources.
25 streamlines the maintenance process and ensures consistent updates across
all platforms.
44
ensures secure access to the application's functionalities and data.
enhances the overall user experience.
45
WE CLAIM:
1. A method (400) for managing application deployment across a plurality of
platforms (218), the method (400) comprising:
5 identifying (402), by an identification unit (212), an application
development framework supporting the plurality of platforms (218) based on
one or more attributes associated with each of the plurality of platforms (218)
and an application;
creating (404), by a processing unit (214), a unified codebase
10 corresponding to the application associated with each of the plurality of
platforms (218) using the identified application development framework;
transforming (406), by the processing unit (214), the created unified
codebase corresponding to the application into a platform-supported codebase
associated with each of the plurality of platforms (218) using the identified
15 application development framework; and
deploying (408), by the processing unit (214), the transformed platformsupported codebase to a distribution channel associated with each of the
plurality of platforms (218).
20 2. The method (400) as claimed in claim 1, wherein for creating the unified
codebase, the method (400) comprising:
generating, by the processing unit (214), a standardized Application
Programming Interface (API) corresponding to one or more of a plurality of
application functionalities associated with the application; and
25 implementing, by the processing unit (214), an authentication
mechanism corresponding to the standardized API generated for the one or
more of the plurality of application functionalities associated with the
application.
46
3. The method (400) as claimed in claim 1, the method comprising:
generating, by the processing unit (214), a platform-specific code
corresponding to the application based on one or more platform functionalities
5 associated with a platform of the plurality of platforms using the identified
application development framework; and
integrating, by the processing unit (214), the platform-specific code
with the unified codebase associated with the application.
10 4. The method (400) as claimed in claim 1, wherein the application is rendered
to an end user based on one or more native components associated with the
platform of the plurality of platforms (218) supported by a user device of the
end user.
15 5. The method (400) as claimed in claim 1, the method comprising:
modifying, by the processing unit (214), the unified codebase associated
with the application based on one or more parameters, wherein the one or more
parameters comprise a new functionality, an error, and a new security protocol;
and
20 updating, by the processing unit (214), the platform-supported codebase
associated with each of the plurality of platforms (218) based on the modified
unified codebase using the identified application development framework.
6. A system (108) for managing an application deployment across a plurality of
25 platforms (218), the system (108) comprising:
an identification unit (212) configured to:
47
identify an application development framework supporting the
plurality of platforms (218) based on one or more attributes associated
with each of the plurality of platforms (218) and an application; and
a processing unit (214) configured to:
5 create a unified codebase corresponding to the application
associated with each of the plurality of platforms (218) using the
identified application development framework;
transform the created unified codebase corresponding to the
application into a platform-supported codebase associated with each of
10 the plurality of platforms (218) using the identified application
development framework; and
deploy the transformed platform-supported codebase to a
distribution channel associated with each of the plurality of platforms
(218).
15
7. The system (108) as claimed in claim 6, wherein, to create the unified
codebase, the processing unit (214) is configured to:
generate a standardized Application Programming Interface (API)
corresponding to one or more of a plurality of application functionalities
20 associated with the application; and
implement an authentication mechanism corresponding to the
standardized API generated for the one or more of the plurality of
application functionalities associated with the application.
25 8. The system (108) as claimed in claim 6, wherein the processing unit (214) is
configured to:
generate a platform-specific code corresponding to the application
based on one or more platform functionalities associated with a platform of the
48
plurality of platforms using the identified application development framework;
and
integrate the platform-specific code with the unified codebase
associated with the application.
5
9. The system (108) as claimed in claim 6, wherein the application is rendered
to an end user based on one or more native components associated with the
platform of the plurality of platforms (218) supported by a user device of the
end user.
10
10. The system (108) as claimed in claim 6, wherein the processing unit (214) is
configured to:
modify the unified codebase associated with the application based on
one or more parameters, wherein the one or more parameters comprise a new
15 functionality, an error, and a new security protocol; and
update the platform-supported codebase associated with each of the
plurality of platforms (218) based on the modified unified codebase using the
identified application development framework.
20 11. A user equipment (UE) (104) communicatively coupled with a network (106),
the coupling comprises steps of:
receiving, by the network (106), a connection request from the UE
(104);
sending, by the network (106), an acknowledgment of the connection
25 request to the UE (104); and
transmitting a plurality of signals in response to the connection request,
wherein based on the plurality of signals, management of an application
deployment across a plurality of platforms (218) in the network (106) is
performed by the method (400) as claimed in claim 1.