It is this simple circular button that triggers the primary action in your app and changes its appearance as it responds to the button click. In this article, we are going to see the various ways types of FloatingAction buttons and ways to implement them in HarmonyOS.

In most scenarios you must have seen the floating button in the bottom right corner for easy access, however, this position is not mandatory we can customize the position, color, icon, and the number of sublayers you prefer as shown below.

We can also have nested floating buttons which leads to layered floating buttons, in case your app requires more action items then this could be used.

let’s see the usage of the FloatingActionButtton Library in HarmonyOS Mobile App and the setup required.

If you are new to HarmonyOS then do check out the articles about HarmonyOS here.

More info on the FloatingActionButtton library can be found here

Step by Step Implementation

1.DevEco Studio

Here we would be using DevEco studio IDE which is designed exclusively to run HarmonyOS applications, if you haven’t installed one then you can get it from the official link with the SDK. Also, we have a step by step instructions for the environment setup available here.

2. Project Creation

Once you have the DevEco Studio up running you can create a select a ”File” -> New -> New Project Option, then you are presented with multiple templates to choose from, select the template as shown below which is Empty Ability.

As a next step, you will have to “Configure the Project” with the project details, and path and ensure to select

• Language as Java and
• API version to 5

After the initial setup, you are ready to start working on the application.

3. Dependency

Next add the FloatingActionButtton Dependency, in order to use the library in your HarmonyOS mobile app, you need to first install it by adding the below dependency in your entry/build.gradle file.

dependencies {
    implementation 'io.openharmony.tpc.thirdlib:floatingactionbutton:1.0.0'
}

4. Define layout via XML

Add the com.github.clans.fab.FloatingActionButton to your layout XML file.

<StackLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:id="$+id:parent"
    ohos:height="match_parent"
    ohos:width="match_parent">

    <com.github.clans.fab.FloatingActionButton
        ohos:id="$+id:fabBtn"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:bottom_margin="12vp"
        ohos:fab_elevation="4vp"
        ohos:image_src="$media:ic_menu"
        ohos:layout_alignment="bottom|right"
        ohos:right_margin="16vp"/>

</StackLayout>

5. Now we can add the java API for customization as shown below.

@Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        ComponentContainer root_layout = (ComponentContainer)LayoutScatter.getInstance(getContext()).parse(ResourceTable.Layout_slice_home, null, false);
        mFab = (FloatingActionButton) mRootId.findComponentById(ResourceTable.Id_fabBtn);
    }

The below code helps to define the FloatingAction Menu in HarmonyOS

Add the com.github.clans.fab.FloatingActionMenu to your layout XML file.

<com.github.clans.fab.FloatingActionMenu
        ohos:id="$+id:menu_green"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:align_parent_bottom="true"
        ohos:align_parent_right="true"
        ohos:bottom_margin="10vp"
        ohos:left_margin="10vp"
        ohos:menu_animationDelayPerItem="500"
        ohos:menu_colorNormal="#43A047"
        ohos:menu_colorPressed="#2E7D32"
        ohos:menu_icon="$media:ic_star"
        ohos:right_margin="150vp"
        ohos:top_margin="10vp"
        >

        <com.github.clans.fab.FloatingActionButton
            ohos:height="match_content"
            ohos:width="match_content"
            ohos:fab_colorNormal="#43A047"
            ohos:fab_colorPressed="#2E7D32"
            ohos:fab_label="lorem_ipsum"
            ohos:fab_size="1"
            ohos:image_src="$media:ic_edit"/>

    </com.github.clans.fab.FloatingActionMenu>

Now we can add the java API for customization as shown below.

@Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        ComponentContainer root_layout = (ComponentContainer)LayoutScatter.getInstance(getContext()).parse(com.github.clans.fab.sample.ResourceTable.Layout_slice_menu, null, false);
        menuGreen = (FloatingActionMenu) root_layout.findComponentById(ResourceTable.Id_menu_green);
    }

List of XML attributes supported for Floating action Button

Let's see some of the Customising Floating action buttons in action, the first being the loading action button, onclick it gives the loading effect as shown below.

Until now we have seen the standard floating action button and let's see some customizations.

<com.github.clans.fab.FloatingActionMenu
        ohos:id="$+id:menu_red"
        ohos:height="match_content"
        ohos:width="match_parent"
        ohos:align_parent_bottom="true"
        ohos:align_parent_right="true"
        ohos:bottom_padding="10vp"
        ohos:right_margin="10vp"
        ohos:menu_backgroundColor="#ccffffff"
        ohos:menu_fab_size="normal"
        ohos:menu_showShadow="true"
        ohos:menu_shadowColor="#66000000"
        ohos:menu_shadowRadius="4dp"
        ohos:menu_shadowXOffset="1dp"
        ohos:menu_shadowYOffset="3dp"
        ohos:menu_colorNormal="#DA4336"
        ohos:menu_colorPressed="#E75043"
        ohos:menu_colorRipple="#99FFFFFF"
        ohos:menu_animationDelayPerItem="50"
        ohos:menu_icon="$media:/fab_add"
        ohos:menu_buttonSpacing="0dp"
        ohos:menu_labels_margin="0dp"
        ohos:menu_labels_paddingTop="4dp"
        ohos:menu_labels_paddingRight="8dp"
        ohos:menu_labels_paddingBottom="4dp"
        ohos:menu_labels_paddingLeft="8dp"
        ohos:menu_labels_padding="8dp"
        ohos:menu_labels_textColor="#FFFFFF"
        ohos:menu_labels_textSize="14sp"
        ohos:menu_labels_cornerRadius="3dp"
        ohos:menu_labels_colorNormal="#333333"
        ohos:menu_labels_colorPressed="#444444"
        ohos:menu_labels_colorRipple="#66FFFFFF"
        ohos:menu_labels_showShadow="true"
        ohos:menu_labels_singleLine="false"
        ohos:menu_labels_ellipsize="none"
        ohos:menu_labels_maxLines="-1"
        ohos:menu_labels_position="left"
        ohos:menu_openDirection="up"
        ohos:menu_fab_label="your_label_here">

<com.github.clans.fab.FloatingActionButton
        ohos:id="$+id:fab1"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:fab_label="Call"
        ohos:fab_size="1"
        ohos:image_src="$media:ic_call_white_24dp"/>


    <com.github.clans.fab.FloatingActionButton
        ohos:id="$+id:fab2"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:fab_label="Message"
        ohos:fab_size="1"
        ohos:image_src="$media:ic_chat_white_24dp"/>

    <com.github.clans.fab.FloatingActionButton
        ohos:id="$+id:fab3"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:fab_label="Delete"
        ohos:fab_size="1"
        ohos:image_src="$media:ic_delete_forever_white_24dp"/>

</com.github.clans.fab.FloatingActionMenu>

Below the output from the above code.

I think FloatingAction Button is one of the simple, smallest and at the same time most intricating features, if used efficiently we can create powerful components on the Application side.

More info on the FloatingAction library can be found here

Check out more articles on HarmonyOS here.

In this article, we will walk through about CalendarListView Library and how to implement the CalendarListView in HarmonyOS or how to utilize it to the maximum under various scenarios.

The CalendarListView library consists of two many features one being the CalendarList and the other being the DatePicker. This is just not a normal picker it consists of day, month, and year in the Custom user interface.

let’s see the usage of the CalendarListview Library in HarmonyOS Mobile App and the setup required.

If you are new to HarmonyOS then do check out the articles about HarmonyOS here.

More info on the CalendarListview library can be found here

Step by Step Implementation

1.DevEco Studio

Here we would be using DevEco studio IDE which is designed exclusively to run HarmonyOS applications, if you haven’t installed one then you can get it from the official link with the SDK. Also, we have a step by step instructions for the environment setup available here.

2. Project Creation

Once you have the DevEco Studio up running you can create a select a ”File” -> New -> New Project Option, then you are presented with multiple templates to choose from, select the template as shown below which is Empty Ability.

As a next step, you will have to “Configure the Project” with the project details, path and ensure to select

• Language as Java and
• API version to 5

After the initial setup, you are ready to start working on the application.

3. Dependency

Next add the CalendarListView Dependency, in order to use the library in your HarmonyOS mobile app, you need to first install it by adding the below dependency in your entry/build.gradle file.

implementation 'io.openharmony.tpc.thirdlib:CalendarListview:1.0.2'

4. Define layout via XML

<?xml version="1.0" encoding="utf-8"?>
<com.andexert.calendarlistview.library.DayPickerView
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:id="$+id:pickerView"
    ohos:height="match_parent"
    ohos:width="match_parent"
/>

5. Now we can add the java API for customization as shown below.

dayPickerView = (DayPickerView) findComponentById(ResourceTable.Id_pickerView);
dayPickerView.setController(new DatePickerController() {
    @Override
    public int getMaxYear() {
        return 2023;
    }

    @Override
    public void onDayOfMonthSelected(int year, int month, int day) {
    }

    @Override
    public void onDateRangeSelected(SimpleMonthAdapter.SelectedDays<SimpleMonthAdapter.CalendarDay> selectedDays) {

    }
});

We have a set of public method that could be used as listed below.

• getDaysInMonth()
• getMaxYear()
• onDayOfMonthSelected()
• onDateRangeSelected()
• setController()
• getSelectedDays()
• setDay()
• getDate()
• SelectedDays

List of XML attributes supported for CalendarListview

Below is the list of XML attributes that are supported by the library

The first use case is the color change of the current date, using the below snippet.

• Add the property — ohos:colorCurrentDay with the required color.

<com.andexert.calendarlistview.library.DayPickerView
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:id="$+id:pickerView"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:colorCurrentDay="#00ff04"/>

The second use case is to change the color of the selected date, using the below snippet.

• Add the property — ohos:colorSelectedDayText with the required color.

<com.andexert.calendarlistview.library.DayPickerView
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:id="$+id:pickerView"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:colorCurrentDay="#00ff04"
    ohos:colorSelectedDayText="#c300ff"
    />

You get the above display on the emulator.

The third use case is to change the color of the displayed month, using the below snippet.

• Add the property — ohos:colorMonthName with the required color.

<?xml version="1.0" encoding="utf-8"?>
<com.andexert.calendarlistview.library.DayPickerView
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:id="$+id:pickerView"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:colorCurrentDay="#00ff04"
    ohos:colorSelectedDayText="#c300ff"
    ohos:colorMonthName="#89c940"
    />

By using the above snippet you get the below display on the emulator.

By now you must have got an idea of how to use CalendarListviewLayout in HarmonyOS and how to add variations like changing colors on the selected date or range of dates, months.

More info on the CalendarListview library can be found here

Check out more articles on HarmonyOS here.

Introduction

Have you ever created dialogs and found them boring or not visually appealing, and always looked on customizing these dialogs, then we have got you covered in this article.

One-Stop solution to display the various style, themes of dialogs, with styles ranging from iOS, Material, MIUI, and the dialog types like Dialog Box, Tips, Bottom Menu.

Also, we have Kongzue themes Dialog V3 which provides a fully customizable dialog box style for the quick and easy realization of special effects.

Background

First, let’s understand Kongzue’s Dialog and how this led to the creation of DialogV3 in HarmonyOS. Kongzue’s Dialog has pop-up styles that provide the simplest way to invoke a message box, a selection box, an input box, await prompt, a warning prompt, a completion prompt, an error prompt, and so on.

You can find more info on the Konguzue dialog here.

Below are some of the listed available themes and their view in HarmonyOS.

iOS theme

iOS theme dialog box in light and dark modes.

Material theme

The material Theme dialog box in light and dark modes

MIUI theme

MIUI theme dialog box in light and dark modes.

Let’s dive deep into how to implement this in HarmonyOS.

Step by Step Implementation

Step 1: Here we would be using DevEco studio IDE which is designed exclusively to run HarmonyOS applications, if you haven’t installed one then you can get it from the official link with the SDK. Also, we have a step by step instructions for the environment setup available here.

Step 2: Once you have the DevEco Studio up running you can create a select a “File” -> New -> New Project Option, then you are presented with multiple templates to choose from, select the template as shown below which is Empty Ability.

While setting up the project ensure to select the language as Java and API version 5.

• Language as Java and

• API version to 5

Step 4: After the initial setup you are ready to start working on the application.

Step 5: Next add the DialogV3 Dependency, in order to use the library in your HarmonyOS mobile app, you need to first install it by adding the below dependency in your entry/build.gradle file.

dependencies {

implementation fileTree(dir: 'libs', include: ['*.har'])
   implementation 'io.openharmony.tpc.thirdlib:DialogV3:1.0.0'
   testCompile 'junit:junit:4.12'

}

Now we will try some use-cases

1. Input Dialog Box — The input dialog box can be used to get input from users or can be used to validate passwords.

// set the theme IOS,Material,kongzue or MIUI
DialogSettings.style = DialogSettings.STYLE.STYLE_IOS;
// set the mode light or dark
DialogSettings.theme = DialogSettings.THEME.LIGHT;

// Onclick display the messege
InputDialog.build(getContext())
//set the prompt messege
.setTitle("prompt").setMessage("Please
enter the password(123456)")
//set input text to show in prompt messge
.setInputText("111111")
.setOkButton("ok", new

OnInputDialogButtonClickListener(){
    @Override public boolean onClick(String inputStr)
    {
        // check validation of input string
        if (inputStr.equals("123456")) {
            TipDialog.show(getContext(), "success!",
                           TipDialog.TYPE.SUCCESS);
            return false;
        }
        else {
TipDialog.show(getContext(), "Incorrect
password", TipDialog.TYPE.ERROR);
return true;
        }
    }
})
.setCancelButton("cancel")
//Hint for helping user
.setHintText("Please enter the password")
.setInputInfo(new InputInfo()
//maximum length of the input string
.setMAX_LENGTH(6)
)
.setCancelable(true)
.show(getContext());

Below is the output for the Input Dialog Box.

2. Crash DialogBox Display — The crash dialog box can be used to display when your app is not responding.

// set the theme IOS,Material,kongzue or MIUI
DialogSettings.style = DialogSettings.STYLE.STYLE_IOS;
// set the mode light or dark
DialogSettings.theme = DialogSettings.THEME.LIGHT;

// Onclick Wait Dialog crash will apper with messege
MessageDialog.show(getContext(), "Tips", "Crash Messege", "cancel")
.setMessageTextInfo(new TextInfo().setGravity(TextAlignment.LEFT))
.setOnOkButtonClickListener(new OnDialogButtonClickListener() {
    @Override public boolean onClick()
    {
        WaitDialog.show(getContext(),
                        "Preparing to crash...");
        WaitDialog.show(getContext(), "Please wait...");
        EventHandler handler = new EventHandler(
            EventRunner.getMainEventRunner());
handler.postTask(new Runnable() {
            @Override public void run()
            {
getUITaskDispatcher().asyncDispatch(() -> {
  TipDialog.show(getContext(), "success", TipDialog.TYPE.SUCCESS)
    .setOnDismissListener(new OnDismissListener() {
                        @Override public void onDismiss()
                        {
                        // jump(MainActivity.class);

3. Share DialogBox Display — The Share dialog box can be used to share information to the platform available on the user’s device.

// set the theme IOS,Material,kongzue or MIUI
DialogSettings.style = DialogSettings.STYLE.STYLE_IOS;

// set the mode light or dark
DialogSettings.theme = DialogSettings.THEME.LIGHT;

// set the the items to be presesnt in share dialog
itemList.add(new ShareDialog.Item(
    getContext(), ResourceTable.Media_img_email_ios,
    "email"));
itemList.add(new ShareDialog.Item(
    getContext(), ResourceTable.Media_img_qq_ios, "QQ"));

// Show the shared content
 ShareDialog.show(getContext(), itemList, (shareDialog, 
 index, item) -> {
    toast("Clicked：" + item.getText());
    return false;

There are some more uses cases that could be added to this list like

1. Fully Customize Dialog Display

2. Content customized Dialog Display

3. Bottom Menu Dialog Display

4. Notification Dialog Display

5. Serialization of Dialog Display

More of these implementations can be found here in the “entry” folder which is the application module.

List of public APIs for app developers

The public methods are accessible for developers to use the DialogV3 library.

Conclusion

Until now you have seen multiple uses cases, API details, and the implementation, also got the essence of the powerful library DialogV3 with its implementation in HarmonyOS.

If you are interested to try dialog functionality in HarmonyOS using the DialogV3 then you should definitely try the above use cases.

More Information on the library can be found here.

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.

If you would like to know more updates about HarmonyOS 2 you can read the entire article here.

Well, we have been hearing about Huawei that it likely to include HarmonyOS into its 1+8+N smart ecosystem strategy, today we will see what is this 1+8+N is all about and its importance.

The above image depicts the 1+8+N all scenario smart life Strategy, which could be simplified as “1+8+N”.

“1” → Refers to the Smartphones which is one of the most frequently and commonly used device on daily basis, which is connecting and controlling the other devices.( which is the center core of the ecosystem).

“8” → Refers to the non-Smartphones products which are used based on the specific scenario and its requirements. Which includes Wearables, Headphones, PC, Tablet, Speakers, AR/VR glasses, Vehicle Mounted Devices and Huawei vision( Middle layer in the image represents the 8).

“N” → Represents a wide ecosystem of other smart products like printers, games consoles, smart travel, sports, health , entertainment products and so forth (which is the outer layer from the above image).

So, until now we have seen what exactly 1,8, N represent but then what is the “+” represents?

The “+” between 1 and 8 represent the “Huawei Share”, well the next question is what is “Huawei Share”? Huawei Share is the feature that allows you to turn your smartphone into a real server dedicated to storage, from which you can take files from any device that is connected to the same network.

The later “+” between 8 and N represent “HiLink” It can be used to search for and manage all HUAWEI HiLink terminal devices, also to provide you with a more consistent and simplified management experience.

Until now we have analyzed about the 1+8+N and its importance and now let’s see what the use of this Strategy or architecture is.

By using this strategy, we can enable interconnection , interoperability, and the capability of sharing all the devices in all Scenario which is the reason for HarmonyOS existence.

In addition, it can also improve user experience, better ecosystem and maximizes values for the users.

To explain this with an example, say you are listening to music on your phone however you have a better speaker available in the same room that could be used. which is also capable of playing the same music file with better audio quality capabilities, instead it is played on your phone.

In this Scenario the 1+8+N strategy comes in effect and decides that speaker is the better device and gives a better user experience seamless with inter device collaboration.

We have tons of new apps and partnerships announced as Huawei expands the ecosystem and you can find the list of all the uses cases here.

In this article we will also see what a “Super Device” is.

Super Device reveals the true power of HarmonyOS and depicts the era of Internet of everything, so what forms a Super device is the combination of Distributed power HarmonyOS and allowing users to connect with different devices.

This allows users to freely use the capability of its smart devices based on users’ needs.

For example, if you want to watch a movie at home late at night, all you must do is open the Control Panel and drag the smart screen icon to your phone icon, and the movie jumps directly from your phone to the TV. If you’re wearing your HUAWEI Free Buds 4, you can then drag the earphone icon to the phone icon, at which point the movie will play on your smart screen while rerouting its sound through your Free Buds. This is just one example of the Super Device experience.

In simple words it is a combination of the hardware ecosystem(1+8) that are available, with Solutions/Scenarios ( which represents the N) , along with that we have the HarmonyOS key capabilities like (One Hop network connection, Multi Device interaction and Collaboration) gives rise to Super Device.

Hope you got a fair understanding of what is 1+8+N and Super Devices are and follow us for more updates related HarmonyOS. If you think you have learned something, then clap your hands 👏 as many times as you can to show your support!

What is 1+8+N and Super Devices? was originally published in Application-Library-Engineering-Group on Medium, where people are continuing the conversation by highlighting and responding to this story.

Another day to be marked in the history of Huawei’s with the launch of HarmonyOS 2 and all scenario new products launch.

Over the past decade we have seen a significant transformation of products, lot of innovations and trend for the phone based like the 5G.

Huawei’s official HarmonyOS 2 was released on Wednesday (June 2, 2021) and introduced the second version of the in-house OS. HarmonyOS has been around for a couple of years now, but version 2 brings a major shift in the digital era. it will power phones, tablets and smartwatches, not just smart TVs and you can watch the streamed video here.

Huawei also announced approximately 100 other Huawei devices ranging from smartphones to tablets that will be upgraded to run HarmonyOS 2 giving consumers access to a seamless intelligent experience across multiple devices in all different types of scenarios.

What is Current Era?

If we look at the history of Operating system it initially started with DOS and then Windows, Symbian followed by iOS and Android and today we come to a new era where everything is connected and more intelligent.

However, it seems to be complicated and it go through this fragmented experience and how do we solve this?

The current Era looks like every product of device contains an Operating system, If you consider Smartphones, we have a separate OS and smart Watches we have an individual Operating system as shown in the below image.

If we give each type of product an individual Operating system, then it will make the whole system complicated and that’s where the new era of OS Harmony OS is into existence.

HarmonyOS is the Operating system that could be used with the Watch, mobile phones, cars, tablet ,tv and wide range of IOT devices and home appliances. HarmonyOS has been utilized in wide range of products “one as all all as one”. that’s the Chinese name of HarmonyOS.

The goal of HarmonyOS is to satisfy different type of hardware ranging from Mobile phones, TV, watches and it even targets smaller devices with 128K as shown below.

It first and only one to enable such a unique kind of system and starting point for IoT.

WHAT HARMONYOS 2.0 OFFERS

• For Consumers: HarmonyOS integrates various smart devices to implement fast connection, capability collaboration, and resource sharing between different devices. This way, services can be seamlessly transferred to a suitable device that delivers a smooth all-scenario experience.
• For Application Developers: HarmonyOS adopts distributed technologies to make application development possible on different device forms. With HarmonyOS, you have the choice to focus on upper-layer service logic and develop applications in a much easier and more efficient way.
• For Device Developers: HarmonyOS uses a component-based software design to tailor itself to particular device forms based on their respective resource capabilities and service characteristics.

Alongside the announcement, the final version of HarmonyOS began to rollout for 18 Huawei devices that include Huawei Mate 40, P40, Mate 30, and MatePad Pro series devices. Furthermore, HarmonyOS closed beta made its way to 28 devices from different smartphone lineups.

Huawei has decided not only to launch HarmonyOS in the recent devices but also target old devices way back up to 2016.

Below are some of the HarmonyOS features to be highlighted.

1. HomeScreen — The system app icons look smoother and better than the ones on EMUI 11.
2. Control Panel — which is one of the highlighting and interactive features of this release, which consist of shortcut switches like Music controller, super devices, connected devices, volume Controller etc.
3. Smart Folder
4. Super Device

To establish a connection, you just need to drag and drop the icon of that device to form a super device and control that newly connected device directly from your Super Device.

5. File Access is super easy without requiring a data cable and provides faster and secure file sharing between Huawei smartphones, computers, and tablets.

6. Smart Home is also covered a way to connect your home devices and control them all in one place.

7. Comprehensive performance gains for more privacy and security

Furthermore, Huawei has also shared the information about the device adaptation roadmap of HarmonyOS 2.0 including the following:

• From September 10, 2020 — Device with 128KB to 128MB RAM
• From April 21, 2021 — Device with 128MB to 4GB RAM
• From October 2021 — Device with 4GB to more than 4GB RAM

By the end of 2021, Huawei has planned to install HarmonyOS 2.0 in over 300 million. These devices are smartphones, tablets, smart wearables, IoT devices, and devices from third-party product manufacturers.

You can find more updates on the official Huawei link here.

What’s New in HarmonyOS 2 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.

Until now we have seen the importance and how Open Source play a vital role in today’s world, if you haven’t read our article about the Open Source then you can find the details here. Today we will see what some of the common issues we face while working with the Open Source Ecosystem.

It could be in terms of Licensing, security concerns or lack of support etc., in this article we will see all these factors and many more in brief and how to handle them.

Licensing

Even today most of us do not understand the licensing obligations that goes along with it, on top of that there are many projects which lack licenses. This makes it exceedingly difficult for business to comply. I think we need best practices in place to make the Open Source easier.

If you’re publishing a piece of code that you want to distribute as much as possible, maybe having other people helping you with the code, making sure you’re not going to be sued as well as making sure that your name or your company’s name are not going to be used by others without your approval, then the BSD 3 clause license is just the one.

We do have 3 types of Open-Source Licenses

• MIT
• Apache
• GPL

You can read more details about the licensing here

Security

Security as always been an area of concern in order to ensure we do not breach before contributing to the Open Source platforms. Most of the Open Source suffer from irregular security updates or Testing. As per the Open Source Survey result it states that

“78% of companies run open source software, but less than half are managing it properly.”

Open access means the code is available to all, which creates opportunities for cyber threat actors to manipulate code maliciously.

we must ensure proper testing is performed and quality assurance is performed throughout the development process else lack of this check can make the IT infrastructure vulnerable.

It is important to have a dedicated Support team if you are using the Open source project within your organization to perform regular security patches and generate report on regular basis.

Coding Standards

Code standards are set of guidelines to be followed by every individual contributing to an Open Source project. It is a simple procedure to ensure all the submitted code looks similar when merged and gives us a feel that it is committed from a single source.

what are the benefits of using coding standards?

1. Compliance with industry standards.
2. Consistent code quality.
3. Software security from the start.
4. Reduced development cost.

Complexity

Complexity of Open-Source projects slowdown the projects as the ecosystem is geared to innovation than usability.

The diversity of projects is also another contributing factor for complexity,

Open-source way manages complexity is by embracing open standards. The use of open standards allows for better collaboration between different organizations with different interests.

Some more minor factors like Code without Owner, Lack of contributors, too many views on the projects which diverts the vision of the project.

So, by now you must have seen the factors or challenges in Open source and there is always pros and cons of Open Source, you need to identify and address the factors to keep the project running and build a community.

There could be enormous reason why open source may not be perfect, but there are millions of reasons why it is better option than the alternative.

What are the Challenges with Open Source? 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.