#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！原创精华

龙眼Litchi

发布于 2022-7-24 15:38

浏览

1收藏

[本文正在参加星光计划3.0-夏日挑战赛]

本文将介绍如何实现，通过华为分享来分享原子化服务，以及如何上架原子化服务从而实现服务的免安装

0. 前言

原子化服务是鸿蒙的一大特性，在服务中心可以看见许多以卡片形式呈现的原子化服务，这些服务体积小，能够快速部署到手机上实现功能，达到免安装的效果。
同样的，原子化服务另外一种呈现方式就是基于华为分享的，例如A同学希望分享他在京东上看到的一件商品，他可以通过华为分享将该服务页面快速迁移到B同学的手机上，而B同学的手机上并没有安装京东，也能看到呈现画面。

#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区

这里不知道是网络还是应用出现了BUG，总之就没显示出来画面，不过问题不大。接下来我们亲自用案例实现，这个案例首先实现华为分享分享服务，同时要发布测试态原子化服务，这样我们的应用才能够在服务中心以卡片形式呈现，并且实现免安装。

1. 原子化服务分享

1.1 华为分享

本案例在最新版本的Deveco上进行编写，我们需要建立携带原子化服务的JAVA工程，注意是JAVA工程，由于该功能目前还未迁移到JS上，我们需要用JAVA进行编写，同时勾选在服务中心显示。
#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区
具体的华为分享原理，其实就是两端在一个组网近场内，一端封装好要分享的数据通过华为分享传输给另一端。快速传输，免安装的体验感一是数据量小，二是华为分享本身过硬的技术两者结合带来的。多余不在赘述，详情参看官网文档，接入华为分享。

1.2 接入华为分享

1.2.1 创建IDL接口

我们在JAVA同级目录下，创建两个idl接口：

IHwShareCallback
IHwShareService
注意idl接口存放路径一定要是com/huawei/hwshare/third

1.2.2 实现接口

IHwShareCallback

interface com.huawei.hwshare.third.IHwShareCallback {
    [oneway] void notifyState([in] int state);
}
1.
2.
3.

IHwShareService

sequenceable ohos.interwork.utils.PacMapEx;
interface com.huawei.hwshare.third.IHwShareCallback;

interface com.huawei.hwshare.third.IHwShareService {
    int startAuth([in] String appId, [in] IHwShareCallback callback);
    int shareFaInfo([in] PacMapEx pacMapEx);
}
1.
2.
3.
4.
5.
6.
7.

1.3 ShareFaManager类

用于管理分享方与华为分享的连接通道和数据交互，建议不要DIY，DIY空间少，容易出错，直接参考官方文档。

import com.huawei.hwshare.third.HwShareCallbackStub;
import com.huawei.hwshare.third.HwShareServiceProxy;
import ohos.aafwk.ability.IAbilityConnection;
import ohos.aafwk.content.Intent;
import ohos.app.Context;
import ohos.bundle.ElementName;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import ohos.interwork.utils.PacMapEx;
import ohos.rpc.IRemoteObject;
import ohos.rpc.RemoteException;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;

public class ShareFaManager {
    private static final HiLogLabel LABEL_LOG = new HiLogLabel(3, 0xD000F00, "ShareFa");

    private static final String LOG_FORMAT = "%{public}s: %{public}s";

    public static final String HM_FA_ICON = "ohos_fa_icon";

    public static final String HM_FA_NAME = "ohos_fa_name";

    public static final String HM_ABILITY_NAME = "ohos_ability_name";

    public static final String HM_BUNDLE_NAME = "ohos_bundle_name";

    public static final String SHARING_FA_TYPE = "sharing_fa_type";

    public static final String SHARING_THUMB_DATA = "sharing_fa_thumb_data";

    public static final String SHARING_CONTENT_INFO = "sharing_fa_content_info";

    public static final String SHARING_EXTRA_INFO = "sharing_fa_extra_info";

    private static final String TAG = "ShareHmFaManager";

    private static final String SHARE_PKG_NAME = "com.huawei.android.instantshare";

    private static final String SHARE_ACTION = "com.huawei.instantshare.action.THIRD_SHARE";

    private static final long UNBIND_TIME = 20*1000L;

    private Context mContext;

    private String mAppId;

    private PacMapEx mSharePacMap;

    private static ShareFaManager sSingleInstance;

    private HwShareServiceProxy mShareService;

    private boolean mHasPermission = false;

    private EventHandler mHandler = new EventHandler(EventRunner.getMainEventRunner());

    private final IAbilityConnection mConnection = new IAbilityConnection() {
        @Override
        public void onAbilityConnectDone(ElementName elementName, IRemoteObject iRemoteObject, int i) {
        HiLog.error(LABEL_LOG, LOG_FORMAT, TAG, "onAbilityConnectDone success.");
        mHandler.postTask(()->{
            mShareService = new HwShareServiceProxy(iRemoteObject);
                try {
                    mShareService.startAuth(mAppId, mFaCallback);
                } catch (RemoteException e) {
                    HiLog.error(LABEL_LOG, LOG_FORMAT, TAG, "startAuth error.");
                }
                });
            }

            @Override
            public void onAbilityDisconnectDone(ElementName elementName, int i) {
                HiLog.info(LABEL_LOG, LOG_FORMAT, TAG, "onAbilityDisconnectDone.");
                mHandler.postTask(()->{
                    mShareService = null;
                    mHasPermission = false;
                    });
            }
    };

    private Runnable mTask = () -> {
        if (mContext != null && mShareService != null) {
            mContext.disconnectAbility(mConnection);
            mHasPermission = false;
            mShareService = null;
        }
    };

    private final HwShareCallbackStub mFaCallback = new HwShareCallbackStub("HwShareCallbackStub") {
        @Override
        public void notifyState(int state) throws RemoteException {
            mHandler.postTask(()->{
                HiLog.info(LABEL_LOG, LOG_FORMAT, TAG, "notifyState: " + state);
                if (state == 0) {
                    mHasPermission = true;
                    if (mSharePacMap != null) {
                        shareFaInfo();
                    }
                }
            });
        }
    };

    /**
     * 单例模式获取ShareFaManager的实例对象
     *
     * @param context 程序Context
     * @return ShareFaManager实例对象
     */
    public static synchronized ShareFaManager getInstance(Context context) {
        if (sSingleInstance == null && context != null) {
            sSingleInstance = new ShareFaManager(context.getApplicationContext());
        }
        return sSingleInstance;
    }

    private ShareFaManager(Context context) {
        mContext = context;
    }

    private void shareFaInfo() {
        if (mShareService == null) {
            return;
        }
        if (mHasPermission) {
            HiLog.info(LABEL_LOG, LOG_FORMAT, TAG, "start shareFaInfo.");
            try {
                mShareService.shareFaInfo(mSharePacMap);
                mSharePacMap = null;
            } catch (RemoteException e) {
                HiLog.error(LABEL_LOG, LOG_FORMAT, TAG, "shareFaInfo error.");
            }
        }
        // 不使用时断开
        mHandler.postTask(mTask, UNBIND_TIME);
    }

    /**
     * 用于分享服务
     *
     * @param appId 开发者联盟网站创建原子化服务时生成的appid
     * @param pacMap 服务信息载体
     */
    public void shareFaInfo(String appId, PacMapEx pacMap) {
        if (mContext == null) {
            return;
        }
        mAppId = appId;
        mSharePacMap = pacMap;
        mHandler.removeTask(mTask);
        shareFaInfo();
        bindShareService();
    }

    private void bindShareService() {
        if (mShareService != null) {
            return;
        }
        HiLog.error(LABEL_LOG, LOG_FORMAT, TAG, "start bindShareService.");
        Intent intent = new Intent();
        Operation operation = new Intent.OperationBuilder()
            .withDeviceId("")
            .withBundleName(SHARE_PKG_NAME)
            .withAction(SHARE_ACTION)
            .withFlags(Intent.FLAG_NOT_OHOS_COMPONENT)
            .build();
        intent.setOperation(operation);
        mContext.connectAbility(intent, mConnection);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.

1.4 简单案例

这里我们编写一个简单案例，MainAbilitySlice实现的是从相册里面挑选一张照片，作为卡片信息分享出去，用于介绍要分享的内容给被分享者。

1.4.1 效果

#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区

但是这里必须两端都装了该HAP包才能实现，还不满足免安装的效果，必须得至少将原子化服务发布到测试态，后文将会详细介绍。

1.4.2 实现

具体的样式不在这里给出，请参考附件，附上核心代码。
唯一需要主要的是，里面用到的APPID，是在AGC控制台上创建相应项目应用时得到的APPID，可在AGC控制台，我的项目中找到。

package com.huawei.hwshare.third.slice;

import com.huawei.hwshare.third.MainAbility;
import com.huawei.hwshare.third.ResourceTable;
//import com.huawei.hwshare.third.ShareFaManager;
import com.huawei.hwshare.third.ShareFaManager;
import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.ability.DataAbilityHelper;
import ohos.aafwk.content.Intent;
import ohos.aafwk.content.Operation;
import ohos.agp.components.Button;
import ohos.agp.components.Component;
import ohos.agp.components.Image;
import ohos.global.resource.NotExistException;
import ohos.global.resource.RawFileDescriptor;
import ohos.interwork.utils.PacMapEx;
import ohos.media.image.ImagePacker;
import ohos.media.image.ImageSource;
import ohos.media.image.PixelMap;
import ohos.media.photokit.metadata.AVStorage;
import ohos.utils.net.Uri;
import java.io.*;

public class MainAbilitySlice extends AbilitySlice {
    private static  final int imgRequestCode = 1001;
    //核心: 显示分享的图片
    private Image photo;
    private Uri  uri;
    private byte [] picByte;
    InputStream resource;
    private Image cardimage;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main);
        Button btn = (Button) findComponentById(ResourceTable.Id_btn);
        Button btn1 = (Button) findComponentById(ResourceTable.Id_btn1);
        cardimage = (Image) findComponentById(ResourceTable.Id_cardimg1);

        btn1.setClickedListener(new Component.ClickedListener() {
            @Override
            public void onClick(Component component) {
                selectPhoto();
            }
        });
        photo = (Image) findComponentById(ResourceTable.Id_photo);
        btn.setClickedListener(new Component.ClickedListener() {
            @Override
            /*华为分享功能的核心代码*/
            public void onClick(Component component) {
                /*数据包*/
                PacMapEx pacMap = new PacMapEx();
                /*分享的服务类型 默认为0 当前也仅支持0*/
                pacMap.putObjectValue(ShareFaManager.SHARING_FA_TYPE, 0);
                /*分享服务的包名，必选参数*/
                pacMap.putObjectValue(ShareFaManager.HM_BUNDLE_NAME, getBundleName());
                /*额外的信息 非必选*/
                pacMap.putObjectValue(ShareFaManager.SHARING_EXTRA_INFO, "原子化服务分享");
                /*分享的服务的Ability类名，必选参数*/
                pacMap.putObjectValue(ShareFaManager.HM_ABILITY_NAME, MainAbility.class.getName());
                /*卡片展示的服务介绍信息，必须参数*/
                pacMap.putObjectValue(ShareFaManager.SHARING_CONTENT_INFO, "分享成功！");
                /*卡片展示服务介绍图片，最大长度153600，必选参数。*/
                pacMap.putObjectValue(ShareFaManager.SHARING_THUMB_DATA, picByte);
                // byte[] iconImg = getResourceBytes(ResourceTable.Media_icon);
                /*服务图标  非必选参数*/
                //pacMap.putObjectValue(com.huawei.hwshare.third.ShareFaManager.HM_FA_ICON, iconImg);
                // pacMap.putObjectValue(com.huawei.hwshare.third.ShareFaManager.HM_FA_ICON, iconByte);
                /*卡片展示的服务名称*/
                pacMap.putObjectValue(ShareFaManager.HM_FA_NAME, "华为分享服务测试");
                // 第一个参数为appid，在华为AGC创建原子化服务时自动生成。
                ShareFaManager.getInstance(MainAbilitySlice.this).shareFaInfo("942536802034526976", pacMap);
            }
        });

    }
    private byte[] getResourceBytes(int resId) {

        ByteArrayOutputStream outStream = null;

        try {
            resource = getResourceManager().getResource(resId);
            outStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = resource.read(buffer)) != -1) {
                outStream.write(buffer, 0, len);
            }
            outStream.close();
            resource.close();
            return outStream.toByteArray();
        } catch (IOException | NotExistException e) {
            // HiLog.error(TAG, "get resource occurs io exception!");
        } finally {
            if (resource != null) {
                try {
                    resource.close();
                } catch (IOException e) {
                    //   HiLog.error(TAG, "close input stream occurs io exception!");
                }
            }
            if (outStream != null) {
                try {
                    resource.close();
                } catch (IOException e) {
                    //  HiLog.error(TAG, "close output stream occurs io exception!");
                }
            }
        }
        return null;
    }

    //选择图片
    private void selectPhoto() {
        //调起系统的选择来源数据视图
        Intent intent = new Intent();
        Operation opt=new Intent.OperationBuilder().withAction("android.intent.action.GET_CONTENT").build();
        intent.setOperation(opt);
        intent.addFlags(Intent.FLAG_NOT_OHOS_COMPONENT);
        intent.setType("image/*");
        startAbilityForResult(intent, imgRequestCode);
    }
    /*选择图片回调*/
    @Override
    protected void onAbilityResult(int requestCode, int resultCode, Intent resultData) {
        if(requestCode==imgRequestCode && resultData!=null)
        {
            //被选择的图片的uri地址
            String img_uri=resultData.getUriString();
            //定义数据能力帮助对象
            DataAbilityHelper helper=DataAbilityHelper.creator(getContext());
            //定义图片来源对象
            ImageSource imageSource = null;
            //选择的Img对应的Id
            String img_id=null;
            /*
             *如果是选择文件则getUriString结果为dataability:///com.android.providers.media.documents/document/image%3A437，其中%3A437是":"的URL编码结果，后面的数字就是image对应的Id
             */
            /*
             *如果选择的是图库则getUriString结果为dataability:///media/external/images/media/262，最后就是image对应的Id
             */
            //判断是选择了文件还是图库
            if(img_uri.lastIndexOf("%3A")!=-1){
                img_id = img_uri.substring(img_uri.lastIndexOf("%3A")+3);
            }
            else {
                img_id = img_uri.substring(img_uri.lastIndexOf('/')+1);
            }
            //获取图片对应的uri，前缀是content，替换成对应的dataability前缀
            uri=Uri.appendEncodedPathToUri(AVStorage.Images.Media.EXTERNAL_DATA_ABILITY_URI,img_id);
            try {
                //读取图片
                FileDescriptor fd = helper.openFile(uri, "r");
                //RawFileDescriptor rfd = helper.openRawFile(uri,"r");
                imageSource = ImageSource.create(fd, null);
                //创建位图
                PixelMap pixelMap = imageSource.createPixelmap(null);
                //组件显示选择的图片
                photo.setPixelMap(pixelMap);
                picByte = new byte[153600];
                //打包图片
                ImagePacker packer = null;
                try{
                    packer= ImagePacker.create();
                    ImagePacker.PackingOptions packingOptions = new ImagePacker.PackingOptions();
                    //图片格式信息
                    packingOptions.format = "image/jpeg";
                    //图片质量
                    packingOptions.quality = 90;
                    //打包
                    packer.initializePacking(picByte, packingOptions);
                    packer.addImage(pixelMap);
                    //完成打包
                    packer.finalizePacking();


                }finally {
                    packer.release();

                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (imageSource != null) {
                    imageSource.release();
                }
            }
        }
    }

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

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

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.

2. 测试原子化服务

2.1 手动签名

首先我们对工程进行手动签名，得到.cer和.p12文件，这里不再赘述手动签名。
手动签名

2.2 申请原子化服务

进入华为开发者联盟，进入管理中心，点击智慧服务，进入HarmonyOS服务开放平台。

2.3 创建服务

#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区

箭头所指，填工程包名即可，其他自拟，点击确定。

至此，服务创建完成，接下来配置服务。

2.4 申请证书

这里要申请两个证书，.csr和.p7b.

2.4.1 申请.csr证书

#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区

申请完证书后，记得点击下载，我们会获得一个.cer证书。

2.4.2 申请.p7b证书

#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区

申请完后一定记得点击下载，我们会获得.p7b证书
。

至此，我们手上有.p12,.p7b,.cer,.csr四种证书，这里非常重要！

2.5 工程签名

这里用到刚刚申请好的证书，在release一栏进行签名，不是debug哦！
#夏日挑战赛#【FFH】从零实现原子服务一键分享，免安装！-鸿蒙开发者社区
接着编译整个工程，是build APP，不是build hap哦！

这样，我们就获得了APP包！

到这里，我们就能够理解实现原子化服务为啥要APP包，说白了还是把APP上传服务器，用的时候再下载，只不过体积小，实现了无感安装的过程！