My previous article about HarmonyOS and the importance of it can be checked here, I would suggest you go through this article before starting with this.

HarmonyOS for Android Developers — Part 1

What does HarmonyOS have to offer for Android Developers?

· Devices use it only if it is necessary, like a modular operating system.

· The modularized decoupled HarmonyOS can be embedded in various devices according to the requirement.

· Adaptable to a wide variety of devices.

· A distributed app can be developed via the distributed capability kit in the same way a standalone app is created.

· Integrated development environment for multi-device development.

· Multiple languages will be supported by the compiler for unified development.

Ideally, all the devices connected to a user should be able to benefit from the connectivity capabilities of the hardware, regardless of where the software is installed.

HarmonyOS helps us to accomplish this goal by creating a fair ecosystem that is capable of full connectivity in any scenario and allows us to achieve a smart ecosystem.

Below list down some of the comparison between HarmonyOS and Android

What is the equivalent of a AndroidMainifest.xml file?

In Android, an AndroidMainifest.xml file contains information of your package, including components of the application such as activities, services, broadcast receivers, content providers etc. It also includes information related to project such as App name, App Icon, App theme, Permission, app version, sdk version, etc.

<manifest

xmlns:android="http://schemas.android.com/apk/res/android"
package="com.org.example"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="15" />

<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >

<activity
android:name=".MainActivity"
android:label="@string/title_activity_main" >

<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" /></intent-filter>

</activity>
</application>
</manifest>

For same in HarmonyOS we have config.json file which contains information of your app, api version, module, device configuration, etc. also include information related to project such as App name, App Icon, Permission, etc. for more details check here.

{
   "app": {
     "bundleName": "com.org.example",
     "vendor": "vendorName",
     "version": {
       "code": 1000000,
       "name": "1.0.0"
     },
     "apiVersion": {
       "compatible": 5,
       "target": 5,
       "releaseType": "Release"
     }
   },
   "deviceConfig": {},
   "module": {
     "package": "com.org.example",
     "name": ".MyApplication",
     "reqPermissions": [
       {
         "name": "ohos.permission.VIBRATE",
         "reason": "vibration",
         "usedScene": {
           "ability": [
             ".MainAbility"
           ],
           "when": "inuse"
         }
       }
     ],
     "deviceType": [
       "phone"
     ],
     "abilities": [
       {
         "skills": [
           {
             "entities": [
               "entity.system.home"
             ],
             "actions": [
               "action.system.home"
             ]
           }
         ],
         "orientation": "unspecified",
         "name": "com.org.example.MainAbility",
         "icon": "$media:icon",
         "description": "$string:mainability_description",
         "label": "$string:app_name",
         "type": "page",
         "launchType": "standard"
       }
     ]
   }
 }

As you have seen, both the files are containing all the details needed by the OS system about the application. But you have seen one major difference between this two files that is AndroidManifest.xml is in xml format and config.json is in json format. So below is some comparison between important elements

1. Versions details

In AndroidManifest.xml file, you have to put version details in <manifest> tag and sdk version put in <uses-sdk> tag.

<manifest 
 android:versionCode="1"
 android:versionName="1.0" >
 
 <uses-sdk
     android:minSdkVersion="16"
     android:targetSdkVersion="30" />
 </manifest>

In config.json file, you have to put version details in app object.

"app": {
   "version": {
     "code": 101,
     "name": "1.0.0"
   },
   "apiVersion": {
     "compatible": 5,
     "target": 5,
     "releaseType": "Release"
   }
 }

2. Package

In AndroidManifest.xml file, you have to put package name in root tag that is <manifest> tag.

<manifest
 package="com.org.example">
     ...
 </manifest>

In config.json file, you have to put package name in module object.

"module": {
     "package": "com.orzangleli.radarview

}

3. Application details

In AndroidManifest.xml file, you have to put application details under < application> tag.

<application
     android:name=".MainApplication"
     android:allowBackup="true"
     android:icon="@drawable/logo"
     android:label="@string/app_name"
     android:supportsRtl="true"
     android:theme="@style/AppTheme">
 …

…
 </application>

In config.json file, you have to put application details in multiple object deviceConfig and module.

"deviceConfig": {
   "default": {
     "supportBackup": false,
     "network": {
       "cleartextTraffic": true,
       "securityConfig": {
         "domainSettings": {
           "cleartextPermitted": true,
           "domains": [
             {
               "subdomains": true,
               "name": "example.ohos.com"
             }
           ]
         }
       }
     }
   }
 },
 "module": {
   "package": "com.orzangleli.radarview",
   "name": ".MyApplication",
   "deviceType": [
     "phone"
   ],
   "colorMode": "light"
 }

4. Activities and Services

In AndroidManifest.xml file, you have to register Activities and Services under <application> tag with <activity> and <service> tag respective.

<application
     android:icon="@drawable/app_icon"
     android:label="@string/app_name" >
     <activity
         android:label="@string/activity_title"
         android:name=".MainActivity" >
         <intent-filter >
             <action          android:name="android.intent.action.MAIN" />
 
             <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
     </activity>

<service 
         android:name=".MyService"
         android:exported="true"
         />
 </application>

In HarmonyOS, the equivalent of Activity and Service is Ability. So in config.json file you have to register all the abilities under module object as abilities json array. And you can set type(i.e. Page, Service) of ability using type attribute.

"module": {
   …
   "abilities": [
     {
       "name": ".MainAbility",
       "description": "himusic main ability",
       "icon": "$media:ic_launcher",
       "label": "HiMusic",
       "launchType": "standard",
       "orientation": "unspecified",
       "permissions": [
       ],
       "visible": true,
       "skills": [
         {
           "actions": [
             "action.system.home"
           ],
           "entities": [
             "entity.system.home"
           ]
         }
       ],
       "type": "page"
     },
     {
       "name": ".MyService",
       "description": "himusic play ability",
       "icon": "$media:ic_launcher",
       "label": "My Service",
       "launchType": "standard",
       "orientation": "unspecified",
       "visible": false,
       "skills": [
         {
           "actions": [
             "action.play.music",
             "action.stop.music"
           ],
           "entities": [
             "entity.audio"
           ]
         }
       ],
       "type": "service"
     }
   ] 
 }

5. Permission

In AndroidManifest.xml file, you have add permission under < manifest > tag using < uses-permission> tag.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.org.example">
 
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
 
 …
 
 </manifest>

In config.json file, you have to add permission under module object as reqPermissions json array.

"module": {
   "package": "com.org.example",
   "name": ".MyApplication",
   "reqPermissions": [
     {
       "name": "ohos.permission.READ_MEDIA",
       "reason": "reading files",
       "usedScene": {
         "ability": [
           ".MainAbility"
         ],
         "when": "always"
       }
     },
     {
       "name": "ohos.permission.WRITE_MEDIA",
       "reason": "writing files",
       "usedScene": {
         "ability": [
           ".MainAbility"
         ],
         "when": "always"
       }
     },
     {
       "name": "ohos.permission.INTERNET"
     }
   ] 
 }

What is equivalent of Activities and it’s lifecycle?

In Android, an Activity represents a single focused screen with a user interface the user can do. In HarmonyOS you can used PageAbility for provide user interface. A Page ability may contain one ability slice or multiple ability slices that provide highly relevant capabilities.

public class MainAbility extends Ability {

    @Override

    public void onStart(Intent intent) {

        super.onStart(intent);

        super.setMainRoute(MainAbilitySlice.class.getName());

    }

}

In Android, you can override methods from the Activity to capture lifecycle methods for the activity itself. In HarmonyOS, You can override methods from the Ability to capture lifecycle methods for the page ability. for more details about Page Ability and it’s lifecycle please check here.

Below image shows transitions between different lifecycle states of a Page ability and the callbacks to be invoked during the transitions.

What is equivalent of Fragment and it’s lifecycle?

In Android, A Fragment is a piece of an activity which represents a behavior or a portion of user interface. Fragments are a way to modularize your code, compose sophisticated user interfaces for larger screens, and help scale your application UI. In HarmonyOS you have Fraction. A Fraction can be placed in a container (an Ability) as a part of its UI and cannot be used independently. for more details about Fraction and it’s lifecycle please check here.

In below example you can see extended Fraction class with all its lifecycle method overrided.

public class MyFraction extends Fraction {

    @Override
    protected Component onComponentAttached(LayoutScatter scatter, ComponentContainer container, Intent intent) {
        return super.onComponentAttached(scatter, container, intent);
    }

    @Override
    protected void onStart(Intent intent) {
        super.onStart(intent);
    }

    @Override
    protected void onActive() {
        super.onActive();
    }

    @Override
    protected void onInactive() {
        super.onInactive();
    }

    @Override
    protected void onForeground(Intent intent) {
        super.onForeground(intent);
    }

    @Override
    protected void onBackground() {
        super.onBackground();
    }

    @Override
    protected void onStop() {
        super.onStop();
    }

    @Override
    protected void onComponentDetach() {
        super.onComponentDetach();
    }
}

What is equivalent of Services and it’s lifecycle?

In Android, A service is a component that runs in the background to perform long-running operations such as playing music, handle network transactions, interacting content providers etc. It doesn’t have any UI (user interface). In HarmonyOS you have Service Ability. A Service ability is used to run tasks in the background, such as playing music or downloading files. It does not provide a UI for user interaction. for more details about Service Ability and it’s lifecycle please check here.

You can create service ability as follow.

public class ServiceAbility extends Ability {

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
    }

    @Override
    public void onCommand(Intent intent, boolean restart, int startId) {
        super.onCommand(intent, restart, startId);
    }

    @Override
    public IRemoteObject onConnect(Intent intent) {
        return super.onConnect(intent);
    }

    @Override
    public void onDisconnect(Intent intent) {
        super.onDisconnect(intent);
    }

    @Override
    public void onStop() {
        super.onStop();
    }

}

Below image show Transitions between different states in a Service ability’s lifecycle.

What is the equivalent of a LinearLayout?

In Android, a LinearLayout is used to lay your widgets out linearly — either horizontally or vertically. In HarmonyOS you have DirectionalLayout. Directional layout is used to arrange a group of components horizontally or vertically. For more details please check here.

In Android

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">

In HarmonyOS

<DirectionalLayout
    ohos:height="match_content"
    ohos:width="match_parent"
    ohos:orientation="vertical">

What is the equivalent of a RelativeLayout?

In Android, A RelativeLayout lays your widgets out relative to each other. In HarmonyOS you have DependentLayout. DependentLayout provides more layout modes. You can specify the position of each component relative to other components at the same level or the position relative to the parent component. For more details please check here.

<?xml version="1.0" encoding="utf-8"?>

<DependentLayout
xmlns:ohos="http://schemas.huawei.com/res/ohos"
ohos:width="match_content"
ohos:height="match_content"
ohos:background_element="$graphic:color_light_gray_element">

<Text
ohos:id="$+id:text1"
ohos:width="match_content"
ohos:height="match_content"
ohos:left_margin="15vp"
ohos:top_margin="15vp"
ohos:bottom_margin="15vp"
ohos:text="text1"
ohos:text_size="20fp"
ohos:background_element="$graphic:color_cyan_element"/>

<Text
ohos:id="$+id:text2"
ohos:width="match_content"
ohos:height="match_content"
ohos:left_margin="15vp"
ohos:top_margin="15vp"
ohos:right_margin="15vp"
ohos:bottom_margin="15vp"
ohos:text="end_of text1"
ohos:text_size="20fp"
ohos:background_element="$graphic:color_cyan_element"
ohos:end_of="$id:text1"/>

</DependentLayout>

What is the equivalent of a View in HarmonyOS?

In Android, the View is the foundation of everything that shows up on the screen. View is the base class for widgets, which are used to create interactive UI components (buttons, text fields, etc.). In HarmonyOS you have Component class. Component occupies a rectangular area on the screen and is responsible for drawing and event processing in this area. For more details about Component please check here.

Below image showing View hierarchy (Android).

Below image showing Component hierarchy (HMOS).

What is the alternative of a basic UI components (i.e., TextView, EditText, ect) in HarmonyOS?

In Android, there are some pre-define widgets available for creating user interface such as TextView, EditText, Button, etc. In HarmonyOS also there are some pre-define component available in HMOS sdk.

Below is the list of alternative for android widgets.

1. TextView -> Text

In Android, TextView is a UI Component that displays the text to the user on their Display Screen. In HarmonyOS you can use Text. For more details check here.

<Text
     ohos:id="$+id:text_welcome"
     ohos:height="match_content"
     ohos:width="match_content"
     ohos:layout_alignment="horizontal_center"
     ohos:text="welcome"
     ohos:text_size="26fp"
     />

2. EditText -> TextField

In Android, EditText is a user interface control that allows the users to enter some text. In HarmonyOS you can use TextField. For more details check here.

<TextField
    ohos:id="$+id:input_email"
    ohos:height="match_content"
    ohos:width="match_parent"
    ohos:hint="Enter Email"
    ohos:top_margin="8vp"
    ohos:text_size="16fp"
    ohos:padding="16vp"
    ohos:background_element="$graphic:background_text_field"
    ohos:text_input_type="pattern_text"
    />

3. Button -> Button

In Android, Button is a UI that is used to perform some action as soon as the user clicks on it. In HarmonyOS also have Button. For more details check here.

<Button
    ohos:id="$+id:btn_login"
    ohos:height="match_content"
    ohos:width="match_content"
    ohos:text="Login"
    ohos:layout_alignment="horizontal_center"
    ohos:text_size="18fp"  
    ohos:start_padding="20vp"
    ohos:end_padding="20vp"
    ohos:top_padding="16vp"
    ohos:bottom_padding="16vp"
    />

4. ImageView -> Image

In Android, ImageView is a view where you can show image. In HarmonyOS you have Image. For more details check here.

<Image
    ohos:id="$+id:icon"
    ohos:height="200vp"
    ohos:width="200vp"
    ohos:image_src="$media:profile_person"
    ohos:scale_mode="clip_center"
    />

5. Seekbar -> Slider

In Android, Seekbar is an extended Progress bar. A Seekbar comes with a pointer that is draggable throughout the bar either in left or right. This pointer helps to set the progress as well. This helps the user to choose a particular range of values. In HarmonyOS you have Slider. For more details check here.

<Slider
    ohos:id="$+id:slider"
    ohos:width="match_content"
    ohos:height="40vp"
    ohos:max="4"
    ohos:progress="4" />

6. CheckBox -> CheckBox

A CheckBox is the UI control that has two states that are either checked or unchecked. If we have a group of CheckBox, we can select as many as we want, unlike RadioGroup. In HarmonyOS also have CheckBox. For more details check here.

<Checkbox
    ohos:height="match_content"
    ohos:width="match_content"
    ohos:text="Agree"
    />

7. Switch -> Switch

In Android, a switch is a two-state UI element that holds either ON or OFF state. ON generally means Yes and OFF means No. By default, a switch is in the OFF state. A user can change its state many times. In HarmonyOS also have Switch. For more details check here.

<Switch
    ohos:height="match_content"
    ohos:width="match_content"
    ohos:text="Agree"
    ohos:enabled="false"
    />

8. Progressbar -> Progressbar, RoundProgressbar

In Android, we have a progress bar that shows the progress of some action that is happening like pasting a file to some location. A progress bar can be in two modes: a) Determinate Mode, b) Indeterminate Mode.

In HarmonyOS, you have Progressbar and RoundProgressbar. For more details check here.

<ProgressBar
    ohos:id="$+id:progressbar"
    ohos:progress_width="10vp"
    ohos:height="60vp"
    ohos:width="600vp"
    ohos:max="100"
    ohos:min="0"
    ohos:progress="60"/>

<RoundProgressBar
     ohos:id="$+id:round_progress_bar"
     ohos:height="200vp"
     ohos:width="200vp"
     ohos:progress_width="10vp"
     ohos:progress="20"
     ohos:progress_color="#47CC47"/>

9. Toast -> ToastDialog

In Andorid, Toast can be used to display information for the short period of time. A toast contains message to be displayed quickly and disappears after some time. In HarmonyOS you have ToastDialog. For more details check here.

new ToastDialog(getContext())
        .setText("This is a ToastDialog displayed in the middle")
        .setAlignment(LayoutAlignment.CENTER)
        .show();

What is the equivalent of a Drawables in HarmonyOS?

In Android, A drawable resource is a general concept for a graphic that can be drawn to the screen and which you can retrieve with APIs such as getDrawable(int) or apply to another XML resource with attributes such as android:drawable and android:icon. There are several different types of drawables: such as Shape Drawable, Vector Drawable, Scale Drawable, ect.

In HarmonyOS you have Element. Element an abstract class of something that can be drawn. When static images need to be displayed in an application, this class and its child classes can be used to draw shapes and images. There are several subclasses which is used as per the type of Element such as ShapeElement, VectorElement, PixelMapElement. For more details check here.

How do I create notification in HarmonyOS?

In Android, A notification is a message you can display to the user outside of your application. you need to set the notification’s content and channel using a NotificationCompat.Builder object. Also it is compulsory from Android Oreo to create notification channel. And for showing notification you need NotificationManager object.

Same in HarmonyOS also we have notification for displaying message outside of application. To create notification in HarmonyOS you need NotificationRequest object to set notification’s content, slot(channel) and other details. In HarmonyOS equivalent of NotificationChannel is NotificationSlot. And with the help of NotificationHelper class you can publish your notification. For more details about notification check here.

//Create notification slot.
 NotificationSlot notificationSlot = new NotificationSlot("notification_001", "low priority", NotificationSlot.LEVEL_LOW);
 notificationSlot.setEnableVibration(true);
 notificationSlot.setEnableLight(true);
 try {
     NotificationHelper.addNotificationSlot(notificationSlot);
 } catch (RemoteException e) {
     e.printStackTrace();
 }
 
 //Create notification.
 NotificationRequest notificationRequest = new NotificationRequest();
 NotificationRequest.NotificationNormalContent content = new NotificationRequest.NotificationNormalContent();
 content.setTitle("Notification");
 content.setText("Hi there");
 NotificationRequest.NotificationContent notificationContent = new NotificationRequest.NotificationContent(content);
 notificationRequest.setTapDismissed(true);
 notificationRequest.setSlotId("notification_001");
 notificationRequest.setContent(notificationContent);
 notificationRequest.setIntentAgent(getLaunchAction());
 try {
     NotificationHelper.publishNotification(notificationRequest);
 } catch (RemoteException e) {
     e.printStackTrace();
 }

// Create Intent agent.
 private IntentAgent getLaunchAction() {
     Operation operation = new Intent.OperationBuilder()
             .withDeviceId("")
             .withBundleName(this.getBundleName())
             .withAbilityName("com.huawei.notification.SecondAbility")
             .build();
     Intent intent = new Intent();
     intent.setOperation(operation);
     List<Intent> intentList = new ArrayList<>();
     intentList.add(intent);
     List<IntentAgentConstant.Flags> flags = new ArrayList<>();
     flags.add(IntentAgentConstant.Flags.UPDATE_PRESENT_FLAG);
     IntentAgentInfo paramsInfo = new IntentAgentInfo(90, IntentAgentConstant.OperationType.START_ABILITY, flags, intentList, null);
     return IntentAgentHelper.getIntentAgent(this, paramsInfo);
 }

How do I Add Animation on any component in HarmonyOS?

In Android, you either create animations using XML, or call the animate() method on a view. Also using ValueAnimator you have more control over animations and customize them at each step of execution.

In HarmonyOS, java sdk provides three major classes for animation: FrameAnimationElement, AnimatorValue, AnimatorProperty, and AnimatorGroup. For more details please check here.

What is the equivalent of local database(SQLite) in HarmonyOS?

In Android, for managing local data of application we have SQLite database and for small amount of data we have SharedPreference where we can store the data in the key-value pairs.

In HarmonyOS, the Object Relational Mapping (ORM) database is masks operations in structured query language (SQL) in the underlying SQLite database, and provides a series of object-oriented APIs for adding, deleting, modifying, and querying entities and relational data. The ORM is an abstraction layer above the SQLite database. For more details about ORM database please check here.

You can see the workflow of ORM database in below figure.

In HarmonyOS, the equivalent of SharedPreference is Lightweight Preference. In the Lightweight Preference you can store the data in the form of key-value pairs. For more details about Lightweight Preference please check here.

You can see the workflow of Lightweight Preference database in below figure.

Example of Lightweight Preference database:

Context context = getApplicationContext(); // Storage path of data files: /data/data/{PackageName}/preferences
 DatabaseHelper databaseHelper = new DatabaseHelper(context);// The input parameter context is of the ohos.app.Context type.
 String fileName = "test_pref"; // fileName indicates the file name, which cannot be empty or contain a path. The default path can be obtained by calling context.getPreferencesDir().
 Preferences preferences = databaseHelper.getPreferences(fileName);
 
 //Read data
 int value = preferences.getInt("intKey", 0);
 
 //Write data
 preferences.putInt("intKey", 3);
 preferences.putString("StringKey", "String value");
 preferences.flush();

HarmonyOS for Android Developers — Part 2 was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mobile devices such as smartphones and tablets run the Android operating system, which is developed under an open-source and Linux-based model. The Android platform enables developers to develop on a unified platform for developing applications for mobile devices, so their applications are likely to run on different Android-powered devices.

Whereas on the other hand, a microkernel-based operating system, such as HarmonyOS, is considered to be safer and more efficient than hybrid kernel-based operating systems.

In order to successfully connect with other platforms on its devices, Huawei developed a multi-cloud platform operating system called HarmonyOS.

In its inception, HarmonyOS has been called an embedded operating system, and is meant for industrial applications or devices that are part of the Internet of Things.

In addition to being multiplatform operating systems and created by two leading technology companies, Android and HarmonyOS share numerous similarities. In reality, these two platforms are very different.

HarmonyOS comes with Linux Kernel, Micro Kernel, and Lite OS. The OS consists of multiple kernels to select an appropriate kernel for devices of varying resource capabilities.

Let us see the architectural diagrams of Android and HarmonyOS:

Based on the architecture diagram below, Android consists of a stack of software components that are roughly divided into five sections and four layers.

Android Libraries

Libraries that are specifically designed for Android usage can be found in this category.

The following is a summary of some of the key Android libraries available to developers:

Android. app − This is the kernel of all Android applications and provides access to the application model.

Android. content − Enables applications to access, publish, and message content.

Android. database − Contains an SQLite database and management classes where users can access the content.

android.OpenGL − API for rendering 3D graphics using OpenGL ES.

Android. os − Contains standard operating system services, such as message access, network access, and inter-process communication.

Android. text − Renders text and manipulates it on a display device.

Android. view − User interface components that make up an application.

Android. widget — A component for designing graphical user interfaces that includes elements such as buttons, labels, list views, layout managers, and radio buttons.

android.WebKit − Provides a way to incorporate web-browsing functionality into applications.

The Java-based Android runtime libraries are now covered, and we’ll be looking at the C/C++-based libraries in this layer of the Android stack.

Android Runtime

Located on bottom of the second layer, this is the third section in the architecture. It provides a key component called Dalvik Virtual Machine, an Android-specific Java Virtual Machine.

As part of the Android runtime, developers can also use standard Java programming languages to write Android applications.

Application Framework

As a result of the Application Framework layer, there are many higher-level services available to applications. These services are available to application developers.

Below is a list of key services provided by the Android framework:

Activity Manager − Manages the lifecycle and stack of activities for the application.

Content Providers − Publishes and shares data among applications.

Resource Manager − Accesses embedded non-code resources such as strings, colors, and user interface layouts.

Notifications Manager − Shows alerts and notifications when an application is running.

View System − A user interface created by extending view classes.

Applications

In the top layer, you’ll find all the Android apps. This layer will be the only one on which you will install your application. Contacts Books, Browsers, Games, etc. are some examples.

HarmonyOS consists of four layers.

· Kernel Layer

· System Service Layer

· Framework Layer

· Application Layer

Kernel Layer

Kernels are foundational layers of operating systems. With HarmonyOS, multiple kernels can be selected for devices with different resource limits. The kernel abstraction layer (KAL) shields differences in Kernel implementations and provides the upper layer with kernel functionality such as management of processes, threads, memory, and file systems, as well as peripheral management.

System Service Layer

System services enable HarmonyOS to provide applications with services through its framework layer.

Basic Software Service

The HarmonyOS provides common and universal features, including events, notifications, and telephony, design, and more In addition to Mobile Sensing Development Platform (MSDP) & Device Virtualization (DV) for X(DFX).

Enhanced Software Service

Integrates a variety of hardware and software services for HarmonyOS, including those devoted to smart TVs, wearables, and IoT devices.

Hardware Service

Delivers hardware services aimed at wearables and IoT devices, such as geolocation and biometric recognition.

Framework Layer

There are two types of applications in this layer: system applications and third-party applications.

Web browsers and email clients are examples of software that forms the Application layer. It provides protocols that allow software to receive and send data and present information to users.

The HarmonyOS app benefits from its own set of Feature Abilities (FAs) and Particle Abilities (PAs).

FAs provide a UI for interacting with users.

Unlike a UI, PAs process background tasks and provide data access from the background.

Applications developed based on FAs and PAs are specifically tailored for business characteristics and can schedule and distribute across devices, providing users with a consistent and efficient experience.

Issues with the current operating system

· Provide seamless user experience.

· The seamless integration of AI.

· OS challenges.

· There are over a million lines of codes.

· Security concerns arise from the interconnection of multiple devices.

· Close coupling prevents the sharing of ecosystems.

Say you are listening to music on your phone, but you can use a speaker in the same room that is more powerful. The same music file can also be played on your phone with better audio quality capabilities. You are not prompted to utilize the best resources on your mobile device. The aim is to integrate devices seamlessly.

Write applications that are not tailored to a single device, but instead take advantage of virtual devices or virtual resources.

As HarmonyOS grows, it will benefit consumers, developers, and equipment vendors. With its cutting-edge OS, HarmonyOS powers the next generation of smartphones and IoT (Internet of Things) applications. HarmonyOS offers users an engaging, diverse, and rich experience. Our goal is to build out this new ecosystem by inviting developers from around the world. Our goal is to provide consumers with intelligent experiences wherever they may be.

The above figure shows the complexity of code management for different devices code base. Developers have to maintain multiple code base for multiple IOT devices.

With other OSs it is difficult in configuring networks for IoT devices due to complex steps and different entries. But with HarmonyOS OneHop network connection this will help in automatic configuration as shown in figure.

Customers, equipment manufacturers, and developers will all reap benefits from HarmonyOS. For next-generation smartphones and internet-of-things (IOT) applications, HarmonyOS is the most advanced OS.

HarmonyOS aims to provide an engaging and diverse experience to its users. As a result, developers all over the world are encouraged to join and participate in this new ecosystem. Together, these technologies will deliver a seamless consumer experience in all situations.

Until now we have seen the importance of HarmonyOS and in Part 2 which is a continuation we will see the What does HarmonyOS have to offer for Android Developers?

Check the next part here

HarmonyOS for Android Developers — Part 2

HarmonyOS for Android Developers — Part 1 was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

We know that GitHub is a highly used software that is typically used for version control. We use it day in and day out to manage and develop projects or contributing to Open Source. We need to follow a workflow which is easier to teach and follow, both of which result in a more consistent application. To put it simply, a workflow is how you get the work done.

In this article we will see what is the Github Flow that we need to follow.

So, let’s understand what Github Flow does and its usage.

Github flow is a standard lightweight workflow followed for easy deployment process and this workflow is used regularly.

Below is the Flow

• Create a Branch
• Commits( create, edit. delete, update)
• Pull request
• Review Code
• Merge the Pull request
• Code Cleanup

The above set of actions needs to be followed rigorously in order to achieve a proper Github flow.

Until now we have seen what a Github Flow is, now let’s see how Github Flow is different from Git Flow.

Basically, Git Flow works with different branches to manage easily each phase of the software development. It is used in environment with “releases” and it is not best suited for Continuous Deployment.

The Structure looks like this, there will be four types of branches:

- master
- release
- hotfix/*
- feature/*

Well, that is not the case with Github Flow, it is more of a continuous deployment environment with no concept of release. The reason is that every time you have a new feature introduced it is pushed live immediately.

If you would like to know more about GitHub Flow you can read here.

Github Tricks and Tips

In this section we will cover some of the random GitHub tips and tricks that would be handy during the Workflow process and can hopefully speed up your development process.

• Organize you contributing guidelines.
• Task list with Markdown as shown below.

- [ ] Tests for Error pages
- [x] Tests for unauthorized access
- [ ] Add Image Check

• Use GitHub Gist while sharing snippets.
• Structuring commits
• Know about Git Blame and Git Bisect
• GitHub code review and exploration using Octotree Plugin.
• Know your .git folder

So far, we have seen the basic GitHub Flow and how is it different from the Git Flow and also some of the unique and random tips. I’d love to hear from you about your favorite GitHub tips that save you time and improve your code workflow.

Understand the Github Flow and tips to improve it. was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

GitHub hosts your source code projects in a variety of different programming languages and keeps track of the various changes made to every iteration.

It is all about the collaborative effort of the community, in reviewing, improving, and deriving new ideas from the uploaded code. It’s definitely something worth looking into!

Some importance features that make Github one of the best and a go to tool.

1. Easy to use and best for open source contribution.
2. Everything is available in spot from documentation, code, issues, updates etc.
3. Easy to share and showcase your contribution.
4. Track share and merge available at single point.
5. Increased Safety with packages.
6. Easy Code hosting.

Since we know the importance of Github now let’s see what guidelines to follow while contributing to Open Source.

1. First create an account on Github
2. Get your Github basic right before diving deep in creating pulling request, forking, or creating your commits.
3. Start creating repositories of the preferred language of your choice.
4. Always ensure when you create the repository the README.md document is available.
5. Before you start contributing to open-source make sure you read the contributing document available in the README file or CONTRIBUTING file of the project. Understand your role and then start contributing.
6. Check if there is any licensing attached to the project.
7. We do have wiki sections/ tab available for most of the projects, please go through the important details which is required towards contribution.

8. Also there is a Security section/Tab if the project as some security guidelines to be followed related Reporting a Vulnerability.

9. Make sure when you commit the code to open-source you use proper naming convention for the commit message if there one in the contributing guidelines.

10. If you are a first-time contributor, please ensure you recheck your commit, tags, descriptions, tests passing and all the relevant details are available.

11. Avoid duplicate issues, please go through the closed issues to avoid duplicates.

So, I recommend you go out and explore various projects on GitHub and start contributing and become a part of Open-Source Community.

If you would like to share your first-time experience in contributing to Open-Source, then leave your comment below.

GitHub insights for Open-Source contribution. was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

Today usage of mobile phones have increased in extensively when compared to that of computers. Mobile phone usage is taking a lead to a computer that it is small in size, light in weight, and can operate with minimum power.

These mobile phones are not limited to speaking only, it is used in making video, recording information and transmitting it to a phone or a computer.

Mobile owners worldwide will increase to 7.33 billion by 2023. The number of mobile phone users in the world will increase significantly in the next four years, as predicted by Statista.

• There are currently 3.5 billion smartphone users worldwide (Statista, 2019).
• 70% of the time is spent with Digital media, Mobile shopping, Office Work etc
• Nearly 90% of mobile internet time is spent in apps.

When we see the usage of apps and Mobile internet usage is rising while desktop internet usage continues to fall. The reason is that we are able to have apps performing most of the task that required Desktops.

So, this infers that apps are built keeping various aspects like screensizes, platforms, usage, geographical conditions, internet connectivity in mind.

There are currently more than 2.9 million apps available in the Google Play Store. (Statista)

Android apps are being published at a rate three times greater than iOS apps (see next stat), with more than 100,000 new apps being released each month.

It’s been observed that 96% of apps in the Google Play Store are free.

There are a lot more options out there that you can explore if you want to learn how to make an app. These ways range from very technical to not that technical at all.

• Building the app from scratch — Extremely technical but highly flexible. This app development method is costly and time consuming, but you can do just about anything with it.
• Hybrid App Development — You develop the app once and deploy it to many platforms using technology like JavaScript.

• React Native · Learn once, write anywhere
• Ionic Framework - The Cross-Platform App Development Leader

• Using Low code platform tools to build apps — It’s not too technical, you can build the apps using drag and drop option and connect with API’s.

• Low-Code Mobile App Development and Data Integration - LANSA
• Zoho Creator: Best Low-Code Custom Application Development Platform

• BuildFire — This method allows you to create an app from scratch with no technical skills.

App Builder | The Best App Maker for High End Mobile Apps

Below are the guidelines for Mobile App development process.

• Define a strategic goals for evolving your idea into a successful app.
• Identify requirements, define team structure, and prepare the roadmap.
• Create seamless and effortless user experience with a polished design.
• Develop backend, API.
• Validate your app with a series of testing criteria.
• Deployment and support.

I hope this article gives you a brief details about app development options. You can use it to choose what’s right for you and your business.

The Rise of Mobile Applications was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

We will discuss and see the factors that makes a code contribution successful and we all rely on and offer some strategies for encouraging contributions on our own projects.

Before we start understanding some of the best practices, let’s see the types of Open-source Users.

• Collaborator
• Consumer
• Maintainer

No matter which project or language you pick the below mentioned practices can be applied. I would suggest analyzing which roles suits you the best then start selecting the project depending on your interest and language of preference.

1. Look for the README.md document

I’m sure any of the well-maintained Open source should contain this document, with proper guidelines indicating ways to contribute. It also helps new team members to see how the code is structured. All these paves way to clean coding, with fewer bugs — meaning lesser time spent in maintenance.

2. There are other ways you can contribute without writing a single line of code.

Replying and handling open issues. We get a lot of issues every day, and some of them may lack necessary information. You can help by guiding people through the process of filling out the issue template, asking for clarifying information, or pointing them to existing issues that match their description of the problem.

Reviewing pull requests for the docs.

Help people write test plans.

3. Questioning

Ask as many questions as possible before raising or submission of issue or ticket and refer documents or review the open issues if required.

4. Review

Review the issue/code and make sure all the necessary information is updated for further analysis.

Make sure you have added the relevant commit message and performed required test.

5. Feedback

Do not consider Feedback as a personal comment, give time for your contributions to be reviewed and use this as a learning experience.

If you feel to contribute by sharing your views or comment about the best practices in code contribution, then feel free to add your comment below.

Best Practices for Code Contribution was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

Reusability is one of the most common and frequently used buzzwords in software development. Developers are building components based on collections of reusable components, recently most of the technologies started to equip themselves with this function.

But the question always lingers as to when do you spend the time to make a thing reusable? How do we really build one? or how do I choose one that caters my needs.

This article as some general guidelines for thinking about reusability and its history.

History of Reusable component?

Below is the definition from Wikipedia about Reusability.

In computer science and software engineering, reusability is the use of existing assets in some form within the software product development process; these assets are products and by-products of the software development life cycle and include code, software components, test suites, designs and documentation.

Code reuse has been practiced from the earliest days of programming. Programmers have always reused sections of code, templates, functions, and procedures.

Software reuse is a recognized area of study in software engineering, however, dates only from 1968 Bell Laboratories proposed basing the software industry on reusable components.

Code reuse aim is to decrease the time and effort of the software development process and increase the quality of the software product significantly, software engineering required new technologies. Nowadays, most software engineering design is based on reuse of existing system or components.

The above image depicts the importance of reusability with the concept of shared reusable components and how efficiently it can be used to builds, distribute, and collaborate over components to build multiple applications and projects.

Why do we need a Reusable component?

We know every application are built using a basic standard approach and adding customization is vital to get started with. Hence if the basic standard is made reusable, we can avoid those hours reinventing the wheel.

When designing interface, break down the common design elements (buttons, form fields, layout components etc) into reusable components with well-defined interfaces. That way, next time you need to build some UI you can write less code, which means faster development time, less bug, and less bytes.

Single page applications have become increasingly more complex over the past. The way we approach, and design application have changed a lot. user interface has become even more interactive and often contain very complex flow. The performance is also another factor to be considered in which user are expecting native like experience.

We need to look for some framework that will help you build the best reusable components and manage the state of the application in a predictable way.

Below are some of the reasons justifying reusable component style?

• Time, Cost and Effort.
• Create a new higher-level abstraction to development.
• Multiple Formats are trending everywhere and need to balance out this.
• Better Usability, there is always demand for simpler and easier UI.
• Avoid repeating work or let go usage of old technology, consistent brand expectation and maximize developer productivity.
• Easier testing.

What is Reusable component?

Repeatability in UI or behavior that can help to define what should be a component.

Components are induvial reusable chunks of code.

Top Tools for Reusable components?

Before we deep dive into the top tools let us understand what is a ideal design system.

A design system is a collection of reusable components, guided by clear standards, that can be assembled to build any number of applications.

List of component tool to aid you scale your productivity consistently and efficiently.

• StoryBook
• Bit
• Styleguidist
• StencilJS

Do’s and Don’ts of Reusable components?

Do’s

• Think before you reuse.
• Self-sufficient.
• Easy to integrate.
• Components are maintainable and reusable.
• Readable and easy to test.

Don’ts

• Many of the “Reusable components” are never reused.
• Components are built to solve hypothetical problem and not the real ones.

Finally, the culture of reusability is just not solve a problem by setting up and sharing it, we need to ensure it is well maintained and agreed. The reason is that most of the software reuse fails is due to the consistence of maintaining it or lack of close feedback loops.

I think Reusable component is not a just a function it is a source of inspiration.

A Deep Dive into Reusable Components. was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

These days developers need to develop applications in both Android and iOS devices and are put in spot to develop an user interface that can be used across both platforms, while maintaining the look and feel. In this situation are developer creating separate UI’s specific to corresponding platform, resulting in increased time and effort?

Achieving the look and feel of native view is a major challenge developer face these days and are the component good enough to act like native or what are the alternatives?

This is where the modern UI tools comes like a life saver with wide range of building block available to the developer. Ranging from buttons, input elements, scrolling list, Grid element and many more. These components are still available but not designed to caters the modern cross platform concerns and constraints in the modern applications.

In order to overcome these challenges, I think we need to explore and make the maximum utilization of the UI component library which is readily available to us, use them in our development process and building a modern application.

Let’s explore some of the best tools in the markets and there productivity meter.

1. Bit

Bit is one of the leading platforms for front- end components, it is fast, dynamic and collaborative way to build your team’s component library. With Bit you can host UI components and collaborate across projects.

Bit. Composable software.

2. StoryBookJs

Storybook is an open source tool for developing UI components in isolation for React, Vue, Angular, and more. It makes building stunning UIs organized and efficient.

Storybook: UI component explorer for frontend developers

3. NativeBase

NativeBase is a free and open source UI component library for React Native to build native mobile apps for iOS and Android platforms.

NativeBase | Essential cross-platform UI components for React Native

4. PatternFly

PatternFly Elements An open-source, flexible design system using Web Components.

PatternFly

5. Elix

Elix is an open collection of high-quality web components for common user interface patterns such as lists, menus, dialogs, carousels, and so on. The modular nature of web components let you easily incorporate them into your web apps, and their standard definition ensures good results across all mainstream browsers.

Elix - Component Kitchen

6. Webcomponents

WebComponents aims to make it easy to share, discover and reuse web components. Web components is a standard created to empower developers to create HTML tags such that <my-new-button> would be valid and able to be utilized across all browsers. It creates a framework agnostic way of composing and repurposing code.

webcomponents.org - Discuss & share web components

7. Stencil

Stencil is a toolchain for building reusable, scalable Design Systems. Generate small, blazing fast, and 100% standards-based Web Components that run in every browser.

Stencil

10. Vaadin web components

Vaadin makes it easy to build beautiful web apps in Java. The included library of UI components is designed to work well on both mobile and desktop. Your users will appreciate the attention to detail while you can focus on the functionality.

Mobile optimized UI components for your web app | Vaadin

9. Polymer Elements

Polymer lets you build encapsulated, reusable Web Components that work just like standard HTML elements, to use in building web applications. Using a Web Component built with Polymer is as simple as importing its definition then using it like any other HTML element:

Polymer/polymer

10. UI5 Web Components (SAP)

UI5 library is a set of lightweight, reusable, and independent UI elements. The components are not however built on top of UI5 but are standalone elements. You can use across frameworks and apps.

OpenUI5

Conclusion

Since you have a brief view of the available tools in the market, I think it is always a good practice to explore the tools in depth and you will be surprised by the available number of options and there unique features.

Do you recommend or have any other tools in mind that you would like to mention then please share your comments with us?

Top Tools for Faster and Productive Development? was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

One of the major reasons for using these libraries is to expedite the development process, i.e., develop an amazing application without any unnecessary or additional efforts.

These libraries provide developers with basic pre-written codes and other important elements that can be used instantly rather than performing these tasks from scratch.

Lets, see some of the guidelines/best practices to be followed

• Firstly, there is no defined set of standards or hard and fast rule available for this. However if you follow a structure it could make things easier and clearer.
• Always stick to the goal as to why you initially started creating this library.
• Keep it simple and straight.
• Do some research and find if there is already an existing library available you just reinvent the wheel, you can actually avoid this.
• It is not always necessary to create libraries, fixing a feature in a existing library is contributing and giving back to the community.
• High quality dependencies
• Permissive license, including (but not limited to) Apache, Artistic, BSD, CC BY, MIT, MS-PL and W3C
• Github Version Tag so you can see exactly what source is in the package.
• Support for the latest stable version
• General usability when it comes to the overview, docs, sample/example code, and API quality.
• Good runtime behavior in terms of CPU and memory usage
• Integration as well as unit test coverage.

Before creating libraries, I would suggest you go through some of the best readily available libraries and see the structure or pattern common in these libraries.

Below are some of the top libraries.

• Dagger 2
• Retrofit
• Picasso
• Glide
• ButterKnife
• RxJava2
• Espresso

The end goal of every library is to simplify abstract complexities of code and package the code for others to reuse in their projects.

If you have any details to be shared or steps to follow while working with libraries then feel free to share it in the comments below.

Things I wish I knew before building Libraries. was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mobile devices are evolving into increasingly sophisticated and general-purpose computers and this has led to the development of a variety of platforms and operating systems in the mobile space.

Everyone would like to create mobile applications and bring their innovate ideas into solutions and sometimes you get overwhelmed choosing which platforms to use and the list of available platforms available.

Today let’s solve this by analyzing the various mobile platforms available in the market and which one to use and when to use it.

First let’s understand the types of app that can be build.

• Native apps
• Hybrid apps
• Web apps

Native Apps

Native apps are built for specific mobile operating system such as Apple iOS or Android OS. An app made for Apple iOS will not work on Android OS or Windows OS.

Hybrid Apps

A Hybrid apps is a software application that combines elements of both native apps and web applications. Hybrid apps are essentially web apps that have been put in a native app shell.

Web Apps

Web apps tends to be built using JavaScript, CSS, and HTML5. Unlike mobile apps, there is no standard software development kit for building web apps.

Now let’s see how to build each category and list of available frameworks.

Native apps

We have handful of best frame-work available in market to start with below is the list.

Flutter

Flutter SDK is Google’s UI toolkit for crafting beautiful, natively compiled applications for mobile, web, and desktop from a single codebase.

Some of the features that makes flutter unique when compared to the rest of the market are.

• Cross Platform Capabilities
• Community
• Fast and Simple App Development
• Unique and rich collection of widgets
• Easy to learn.
• Design Tools

More details about Flutter can be found here.

React Native

React Native is an open-source mobile application framework created by Facebook, Inc. It is used to develop applications for Android, Android TV, iOS, macOS, Web, Windows and UWP by enabling developers to use React framework along with native platform capabilities.

• Time and cost efficiency
• Native look and feel of your apps.
• Sharing the codebase for iOS, Android, and the Web (with React and React Native for Web)
• One team for multiple platforms
• Awesome performance

More details about React Native can be found here .

Swift

Swift is a modern, general-purpose, and multi-paradigm programming language designed by Apple to build their iOS-powered devices.

• Open Source
• Better error Handling
• Easy Scaling
• Less Coding and Scaling
• Faster Coding

More details about Swift can be found here .

Hybrid Apps

Ionic Apps

The Ionic Framework is a complete open-source SDK for hybrid mobile app development. It provides tools and services for hybrid mobile app development using Web technologies like CSS, HTML5, and Sass.

More details about Swift can be found here .

Native Script

Native Script apps are built using JavaScript, or by using any language that transpiles to JavaScript, such as TypeScript, for instance.

More details about Native Script can be found here.

Web Apps

Progressive Web Apps

Progressive Web Apps are something between a responsive website and a mobile app.

They are mobile sites built with modern JavaScript frameworks, designed to work like a native app.

• Reliable
• Fast
• Engaging

More details about Progressive Apps can be found here.

Hence, picking the right platform to develop application is one of the most critical parts of building your app. Hope this article would have aided in you understanding which framework to choose from.

Various Platforms available for Mobile Application Development. was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.