WO2025229684A1 - Method and system for developing multi-platform applications - Google Patents

Abstract

An application development framework supporting the creation of an application for multiple platforms is identified. A unified codebase comprising a unified set of source code is created using the identified application development framework to build applications that can run on multiple platforms. The created unified codebase is transformed into a platform-supported codebase for each platform to address differences in user interface (UI) design, device features, or other platform-specific requirements. The application compiled with the transformed platform-supported codebase is deployed to distribution channels for each platform. The application's functionality is exposed through a standardized interface with which other applications or services interact. The authentication method is also implemented as a security measure.

Description

METHOD AND SYSTEM FOR DEVELOPING MULTI-PLATFORM APPLICATIONS

RESERVATION OF RIGHTS

[0001] A portion of the disclosure of this patent document contains material, which is subject to intellectual property rights such as, but are not limited to, copyright, design, trademark, Integrated Circuit (IC) layout design, and/or trade dress protection, belonging to Jio Platforms Limited (JPL) or its affiliates (hereinafter referred as owner). The owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all rights whatsoever. All rights to such intellectual property are fully reserved by the owner.

TECHNICAL FIELD

[0002] 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 platformspecific adaptations.

DEFINITIONS

[0003] 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.

[0004] The term “Applications” refers to programs designed to perform specific tasks for end-users.

[0005] 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 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.

[0006] The term “Application development framework” refers to a set of pre-built tools and libraries that streamline the process of creating software applications. It provides a standardized structure and common functionalities, allowing developers to build applications more efficiently and with less code.

[0007] 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.

[0008] 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 control, collaboration, and ongoing maintenance.

[0009] 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.

[0010] 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.

[0011] The term “Authentication mechanism” refers to a process used to verify the identity of a user before granting access to the application/software.

[0012] 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.

[0013] These definitions are in addition to those expressed in the art.

BACKGROUND

[0014] 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. 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.

[0015] In the evolving landscape of software development, the demand for 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 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.

[0016] To address these challenges, the cross-platform development frameworks have emerged. These frameworks allow developers to write a single codebase that can be adapted and deployed across various platforms. However, some limitations persist.

[0017] 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 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 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 applications across diverse platforms.

[0018] Therefore, there is a need to overcome the limitations of the prior art.

OBJECTS

[0019] Some of the objects of the present disclosure, which at least one embodiment herein satisfies, are as follows:

[0020] 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.

[0021] Another object of the present disclosure is to enable platform-specific adaptations within the single codebase, ensuring a consistent and native user experience across different target platforms.

[0022] 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.

[0023] 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.

[0024] Another object of the present disclosure is to address platform-specific customization challenges by providing developers with tools and methodologies to achieve truly native user experience on each platform while leveraging the benefits of cross-platform development.

[0025] 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 present disclosure.

SUMMARY

[0026] In an exemplary embodiment, 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 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 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 plurality of platforms.

[0027] 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 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.

[0028] In some embodiments, the method comprises: generating, by the processing unit, 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, the platform-specific code with the unified codebase associated with the application.

[0029] 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.

[0030] 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 of platforms based on the modified unified codebase using the identified application development framework.

[0031] 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 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 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.

[0032] In some embodiments, to create the unified codebase, the processing unit is configured to generate a standardized Application Programming Interface (API) corresponding to one or more of a plurality of application functionalities associated 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.

[0033] In some embodiments, the processing unit is configured to generate 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 to integrate the platform-specific code with the unified codebase associated with the application.

[0034] 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.

[0035] 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 security protocol. Further, the processing unit is configured to update the platform- supported codebase associated with each of the plurality of platforms based on the modified unified codebase using the identified application development framework.

[0036] In yet another exemplary embodiment, a user equipment (UE) communicatively coupled with a network, the coupling comprises steps of receiving, 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, 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 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 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.

[0037] In yet another exemplary embodiment, a computer program product comprising a non-transitory computer-readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to execute 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 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 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 plurality of platforms.

BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWING

[0038] 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. 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.

[0039] 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.

[0040] FIG. 2A illustrates an exemplary block diagram of the system for managing the application deployment across the plurality of platforms, in accordance with an embodiment of the present disclosure.

[0041] FIG. 2B illustrates an exemplary system architecture for managing the application deployment across the plurality of platforms, in accordance with an embodiment of the present disclosure.

[0042] FIG. 3 illustrates an exemplary flow diagram implementing a method for developing multi-platform applications, in accordance with an embodiment of the present disclosure.

[0043] 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.

[0044] FIG. 5 illustrates an exemplary computer system in which or with which the embodiments of the present disclosure may be implemented.

[0045] The foregoing shall be more apparent from the following more detailed description of the disclosure.

LIST OF REFERENCE NUMERALS

100 - Network Architecture

102- 1 , 102-2... 102-N - Users

104-1, 104-2... 104-N - U ser Equipments

106 - Network

108 - System

112 - Centralised Server

200A - System Block diagram

202 - Processor(s)

204 - Memory

206 -Interface(s)

208 - Processing engine

210 - Database

212 - Identification Unit

214 - Processing Unit

200B - System Architecture

216 - Remote Server

218-1, 218-2, 218-3, 218-4...218-N - Platforms 220 - Internet

300 - Method Flow Diagram

400 - Method Flow Diagram 500 - Computer System 510 - External Storage Device 520 - Bus

530 - Main Memory

540 - Read Only Memory

550 - Mass Storage Device

560 - Communication Port

570 - Processor

DETAILED DESCRIPTION

[0046] In the following description, for the purposes of explanation, various specific details are set forth in order to provide a thorough understanding of 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 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 refer to the same parts throughout the different drawings.

[0047] 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 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.

[0048] 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 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 obscuring the embodiments.

[0049] 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. 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.

[0050] 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 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 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.

[0051] Reference throughout this specification to “one embodiment” or “an 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, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0052] 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 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 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 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 equivalent terms or variations thereof may be used interchangeably without departing from the scope of the invention as defined herein. [0053] 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 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.

[0054] 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 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 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 security measures. Developers reuse a substantial portion of the code across different platforms. This minimizes redundancy and improves code efficiency.

[0055] Hereinafter, exemplary embodiments of the present disclosure will be described with reference to the accompanying drawings.

[0056] The various embodiments throughout the disclosure will be explained in more detail with reference to FIGs. 1-5. [0057] 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.

[0058] 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- 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.

[0059] 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) devices, augmented reality (AR) devices, a laptop, a general-purpose computer, a desktop, a personal digital assistant, a tablet computer, and a mainframe computer. 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.

[0060] 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 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 packet- 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.

[0061] In an embodiment, the centralized server (112) is a computing resource that provides resources, data, services, or functionality to other computers, devices, or users 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.

[0062] 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 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).

[0063] 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 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).

[0064] FIG. 2A illustrates an exemplary block diagram (200A) of the system (108) Y1 for managing the application deployment across the plurality of platforms, in accordance with an embodiment of the present disclosure. FIG. 2A is explained with reference to FIG. 1.

[0065] 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).

[0066] In an embodiment, the system (108) may include one or more processor(s) (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 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 Memory (RAM), or a non-volatile memory such as an Erasable Programmable Read Only Memory (EPROM), a flash memory, and the like.

[0067] 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 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). [0068] In an embodiment, the system (108) may include the processing engine (208) that may be implemented as a combination of hardware and programming (for 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 processing engine (208) may comprise a processing resource (for example, one or more processors), to execute such instructions. In the present examples, the machine- readable 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 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.

[0069] In an embodiment, the system (108) may include the database (210) that 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, 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.

[0070] The processing engine (208) comprises an identification unit (212) and a processing unit (214).

[0071] 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 the plurality of platforms and an application.

[0072] 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 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.

[0073] In an aspect, the platform refers to the foundational environment on which software/applications run. The platform provides tools, libraries, and infrastructure to build, deploy, and execute programs.

[0074] 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., 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, 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 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.

[0075] 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.

[0076] The technical attributes refer to attributes that define technology and 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 (API) support, deployment options, integration tools, etc.

[0077] 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, 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, 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.), etc.

[0078] 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, Two- factor authentication (2FA), data encryption at rest, etc.), reliability (e.g., % uptime, 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.

[0079] The application development framework refers to a set of tools and libraries that help developers build applications faster and more efficiently. The 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.

[0080] 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 ‘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 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 (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 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 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 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 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.

[0081] In an aspect, the unified codebase is a core logic of the application that 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 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.

[0082] 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 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 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.

[0083] The plurality of application functionalities comprises, but is not limited to, 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, third- party gateways, etc.), location-based services, data analytics, task and workflow 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.

[0084] 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, 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 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.

[0085] The processing unit (214) is further configured to implement an authentication mechanism corresponding to the standardized API generated for one or more of the plurality of application functionalities.

[0086] 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 (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 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.

[0087] After creating the unified codebase, the processing unit (214) is configured 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 platform- supported codebase refers to a process of modifying, adapting, or restructuring the 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. [0088] Transforming the 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 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.

[0089] 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.

[0090] 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 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.

[0091] The transformed platform-supported 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 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.

[0092] In an aspect, a compiled application (i.e., the transformed platform- supported 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.

[0093] The processing unit (214) is further configured to generate a platformspecific code corresponding to the application based on one or more platform functionalities associated with the platform using the identified application development framework.

[0094] In an aspect, the platform-specific code is generated to address differences in UI design, device features, or any other platform-specific requirements.

[0095] 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, 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 limited to, file system access, window & UI management, clipboard access, notifications, system integration, background services, task scheduling, installer, auto update, etc.

[0096] 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 platformspecific 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. [0097] After generating the platform-specifc code, the processing unit (214) is further configured to integrate the platform-specific code with the unified codebase 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.).

[0098] 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 (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.

[0099] Furthermore, the application development framework provides access to native APIs and features of each platform. This allows developers to incorporate platform-specific functionality and take advantage of device capabilities.

[00100] 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.

[00101] The application development framework (i.e., cross-platform development 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.

[00102] In an aspect, the processing unit (214) is configured to test functioning of 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 testing, user interface (UI) testing, performance testing, security testing, integration testing, usability testing, etc.

[00103] 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 ensures that the application functions correctly on each platform and that the user experience is consistent.

[00104] 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, the developers use platform-specific debugging tools for identification of platformspecific issues.

[00105] 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 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.

[00106] 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.

[00107] 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 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.

[00108] Although FIG. 2A shows exemplary components of the system (108), in 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 the system (108) may perform functions described as being performed by one or more other components of the system (108).

[00109] FIG. 2B illustrates an exemplary system architecture (200B) for managing the application deployment across the plurality of platforms (218), in accordance with an embodiment of the present disclosure.

[00110] 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).

[00111] The system architecture (200B) comprises the memory (204) and the 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).

[00112] Referring to FIG. 2B, in an embodiment, the system architecture (200B) 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, non- platform-specific UI components.

[00113] 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).

[00114] The data models may be representations of the data used by the application. The data models define the structure and organization of the data, independent of how it is stored or accessed on different platforms.

[00115] The non-platform-specific UI components may be reusable UI elements that are used to build the application's user interface across different platforms, non- platform-specific UI components include generic components (e.g., buttons, text fields, or lists). The platform-specific UI elements include native navigation bars.

[00116] 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.

[00117] In an aspect, a specific type of storage technology may be used instead of memory (204) depending on the implementation.

[00118] 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 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).

[00119] 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) may correspond to the computing device (104-N).

[00120] 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 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). [00121] In an embodiment, the platform (218-3) may be configured for web environments. This signifies web browsers on various devices and operating systems. The system would enable development for web applications that run within a web browser, accessible through the internet.

[00122] 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. 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).

[00123] 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 application development (e.g., N=2 for Windows and macOS).

[00124] 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).

[00125] In an embodiment, the remote server (216) plays a central role in the system (108) for platform- independent application development. The remote server (216) may be a repository for hosting the developed application and its associated Application 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).

[00126] In an aspect, the remote server (216) may facilitate communication 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.

[00127] 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).

[00128] In an embodiment, the database (210) may be connected to the remote 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.

[00129] 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 by one or more other components of the system 108.

[00130] FIG. 3 illustrates an exemplary flow diagram implementing a method (300) for developing multi-platform applications, in accordance with an embodiment of the present disclosure.

[00131] FIG. 3, with reference to FIGs. 1-2B, illustrates the method (300) for developing the multi-platform applications.

[00132] 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, establishing a unified codebase promotes efficient development by allowing developers to write the core logic once and reuse the unified codebase for various platforms.

[00133] At step (304), the method (300) includes employing a cross-platform development framework supporting the platform (218) and integrating platformspecific code within the framework to adapt to the platform's requirements. The method (300) may utilize the platform-specific code within the chosen framework.

[00134] The platform-specific code includes platform-specific UI components and platform-specific application programming interfaces (APIs).

[00135] The platform-specific UI components (e.g., buttons, navigation bars) mimic the native appearance and behavior of the UI elements on the target platform.

[00136] The platform-specific code interacts with features and functionalities offered by the underlying platform's APIs (e.g., camera, GPS).

[00137] 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 maintaining a single codebase for core functionalities.

[00138] 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 external applications or services. This standardized API facilitates seamless communication and integration with external systems. [00139] 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 exposed through the API, enhancing the application's overall security.

[00140] 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 across multiple platforms.

[00141] 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 reaches intended audience through popular distribution channels.

[00142] 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 over time.

[00143] 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.

[00144] FIG. 4, with reference to FIGs. 1-3, illustrates the method (400) for managing the application deployment across the plurality of platforms (218).

[00145] 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 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.

[00146] 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 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.

[00147] The processing unit (214) creates the unified codebase corresponding to each platform using the identified application development framework (e.g., cross platform development framework). The unified codebase is created in a unified development environment using a single set of programming languages, tools, and 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.

[00148] 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 (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.

[00149] 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 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.

[00150] The processing unit (214) is further configured 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. 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, 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 authorization (i.e., what actions users are allowed to perform) as security measures.

[00151] 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) 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 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 platformspecific 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 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.

[00152] 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 platform- 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 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 services, and deploying the codebase to the distributed channel, etc.

[00153] 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 platformspecific 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 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 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.). 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 code into native code for each platform.

[00154] 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 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.).

[00155] The method (400) further comprises modifying, by the processing unit (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, 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.

[00156] The method (400) further comprises 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. 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 handles the compilation, packaging, and deployment processes corresponding to updates or maintenance for each platform.

[00157] FIG. 5 illustrates an exemplary computer system (500) in which or with which the embodiments of the present disclosure may be implemented.

[00158] As shown in FIG. 5, the computer system (500) may include an external 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 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 modembased 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.

[00159] 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 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 interfaces).

[00160] 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 (PCI- X) bus, Small Computer System Interface (SCSI), Universal Serial Bus (USB), or the 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).

[00161] 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 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. [00162] The exemplary computer system (500) is configured to execute a computer program product comprising a non-transitory computer-readable medium comprising 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 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 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.

[00163] The present disclosure provides technical advancements related to the management of an application deployment across multiple platforms. The 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 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 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 than managing multiple codebases. Reuse of a substantial portion of the unified code across different platforms minimizes redundancy and improves code efficiency.

[00164] 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. 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

[00165] 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. streamlines the maintenance process and ensures consistent updates across all platforms. ensures secure access to the application's functionalities and data. enhances the overall user experience.

Claims

1. A method (400) for managing application deployment across a plurality of platforms (218), the method (400) comprising: 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 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 application development framework; and deploying (408), by the processing unit (214), the transformed platform- supported codebase to a distribution channel associated with each of the plurality of platforms (218).

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 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.

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 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.

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.

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 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 platforms (218), the system (108) comprising: an identification unit (212) configured to: 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: 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 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).

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 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.

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 plurality of platforms using the identified application development framework; and integrate the platform-specific code with the unified codebase associated with the application.

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. 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 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.

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 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.

12. A computer program product comprising a non-transitory computer- readable medium comprising instructions that, when executed by one or more processors, cause the one or more processors to execute a method (400) for managing application deployment across a plurality of platforms (218), the method (400) comprising: 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 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 application development framework; and deploying (408), by the processing unit (214), the transformed platform- supported codebase to a distribution channel associated with each of the plurality of platforms (218).