Smart Sync Tutorial | Smart Sync Admin Tools | In-Outbound Handling
In this section, we will:
Smart Synchronization application development is not different from the normal software development. Therefore, the best practices for a successful software development also apply to Smart Synchronization application development. However, it is also useful to be aware of the additional best practices for the effective and efficient Smart Sync application development. The key factors for a successful Smart Sync application development are as follows:
The following diagram describes the development process taking these key factors into consideration:
Some of the most important artifacts in the planning phase are as follows:
One of the key decisions in the planning phase is to identify the business objects in the backend system and to decide how they are represented in the client application. Since one of the core functions of an Smart Sync application is that the business objects updated on a client device is successfully uploaded to a backend system and vice versa, it is very important to identify which business object in a backend system can be used and to identify the dependencies of the business objects on other objects. The identification of the business objects is typically followed by the identification of existing BAPIs. Then, it is necessary to identify the header and item structures of each object.
On the client side, the same business object identification process is required based on the requirements. It is especially important to identify whether the downsized or merged version of the business objects in a backend system can be used.
In most cases, BAPI wrappers are responsible for absorbing the differences between the client-side business objects and those in a backend system. However, if they are greatly different, it should be carefully investigated whether BAPI wrappers can really absorb the differences.
Since the GUI requirements of client applications can differ greatly from an application to another depending on the target application users, it is advisable to conduct a preliminary usability test with potential users of the application and to agree on the GUI design and navigation model used in the application as early as possible.
Finally, before moving on to the first development cycle, it is worth planning which use cases will be covered in each development cycle (For more information, refer to Iterative / Use Case Driven Development).
In each development cycle in the implementation phase, the client- and server-side components can be developed in parallel. However, it is important to be aware of the following dependencies:
For efficient parallel development, therefore, it is important to plan the activities accordingly taking these dependencies into account.
At the end of each development cycle, it is important to conduct the integration/synchronization test, which should include the following:
Performing the integration/synchronization test at the end of each development cycle is beneficial because it makes it possible to identify issues and risks that should be addressed in the next development cycle.
After the completion of all the development cycles and testing, SyncBOs and BAPI wrappers are moved to the production system and an installation package of the client application is put in a Mobile Infrastructure server for automatic deployment to client devices.
It is rarely the case that the first plan remains unchanged throughout the entire development cycle, no matter how thoroughly the planning is conducted. Thus, as widely recommended in modern software development process, the iterative and incremental development is one of the key factors also for a successful Smart Sync application development. For an effective iteration, the following can be applied:
Suppose that it is identified that “customer” business object is
not dependent on other main business objects although it uses “country”
and “region” business objects. Suppose also that “sales order”
business object refers to “customer” business object.
Then, the first cycle might cover only “customer” business object
and related ones such as “region” and “country” objects,
and not “sales order” business object. Furthermore, the first cycle
might just concentrate on the display of customer list and detail use cases,
and the creation of a customer use case might be covered in a later cycle.
The benefits of such an iterative approach is as follows:
The keys of the server-side development are as follows:
The table below describes the skills/knowledge and tasks required:
Target System |
Skill / Knowledge | Task |
Web AS 6.20 | Smart Sync SyncBO builder | Defining SyncBOs (parameter settings) |
Backend SAP system | Backend application knowledge (inc. BAPIs available), ABAP | BAPI wrapper (ABAP function module) development |
In the planning phase, it is important to identify the business scenario and
the business objects required, which is followed by the identification of appropriate
BAPIs available in the target backend system. It is important to agree on how
the identified business objects are represented in the client application. If
the business objects used in a backend system are very different from ones in
client devices, BAPI wrappers may need to absorb the differences. This can be
done also on the client-side application; however, it is often the case that
it is less effective to do that.
In the implementation phase, ABAP programming is required for each BAPI wrapper, and SyncBOs need to be defined using the SyncBO Builder. The SyncBO Builder will generate the runtime component (synchronizer) for each SyncBO. Then, using the SyncBO Builder, it is also necessary to generate the so-called meta-data XML, which is referenced by a client application that accesses the SyncBOs defined.
![]() |
Often, it is a useful approach to define a SyncBO as soon as possible when BAPI wrapper interfaces are defined and activated for the SyncBO but before implementing the logic in BAPI wrappers. This makes it possible to generate a meta-data XML, which is often referenced during developing SyncBO access logic of a client application. |
In the testing phase, the synchronization test needs to be performed. Finally, in the deployment phase, the BAPI wrappers and SyncBOs are transported to the target production systems.
The diagram below describes the simplified process of the server-side application development and where the details are covered in this cookbook:
For details of BAPI wrapper development, refer to BAPI Wrapper Development.
For details of defining SyncBO, refer to Defining Synchronization Business Object
(SyncBO).
The key deliverable of the client-side application development is a compiled JSP/AWT application in an archive file such as a .war/.jar file.
The skills/knowledge required for the client application development are JSP/AWT application development skills as well as the business requirements of the client application.
The client-side application development is not different from a normal JSP/AWT application development. One of the differences is, however, that the data access is performed using Smart Sync APIs.
Some of the important considerations in the client application development are as follows: