HarmonyOS Developer 开发指导

import http from '@ohos.net.http';

// 每一个httpRequest对应一个http请求任务，不可复用
let httpRequest = http.createHttp();

// 用于订阅http响应头，此接口会比request请求先返回。可以根据业务需要订阅此消息
// 从API 8开始，使用on('headersReceive', Callback)替代on('headerReceive', AsyncCallback)。 8+
httpRequest.on('headersReceive', (header) => {
    console.info('header: ' + JSON.stringify(header));
});

httpRequest.request(
    // 填写http请求的url地址，可以带参数也可以不带参数。URL地址需要开发者自定义。请求的参数可以在extraData中指定
    "EXAMPLE_URL",
    {
        method: http.RequestMethod.POST, // 可选，默认为http.RequestMethod.GET
        // 开发者根据自身业务需要添加header字段
        header: {
            'Content-Type': 'application/json'
        },
        // 当使用POST请求时此字段用于传递内容
        extraData: {
            "data": "data to send",
        },
        connectTimeout: 60000, // 可选，默认为60s
        readTimeout: 60000, // 可选，默认为60s
    }, (err, data) => {
        if (!err) {
            // data.result为http响应内容，可根据业务需要进行解析
            console.info('Result:' + data.result);
            console.info('code:' + data.responseCode);
            // data.header为http响应头，可根据业务需要进行解析
            console.info('header:' + JSON.stringify(data.header));
            console.info('cookies:' + data.cookies); // 8+
        } else {
            console.info('error:' + JSON.stringify(err));
            // 该请求不再使用，调用destroy方法主动销毁。
            httpRequest.destroy();
        }
    }
);

import webSocket from '@ohos.net.webSocket';

var defaultIpAddress = "ws://";
let ws = webSocket.createWebSocket();
ws.on('open', (err, value) => {
    console.log("on open, status:" + JSON.stringify(value));
    // 当收到on('open')事件时，可以通过send()方法与服务器进行通信
    ws.send("Hello, server!", (err, value) => {
        if (!err) {
            console.log("Message sent successfully");
        } else {
            console.log("Failed to send the message. Err:" + JSON.stringify(err));
        }
    });
});
ws.on('message', (err, value) => {
    console.log("on message, message:" + value);
    // 当收到服务器的`bye`消息时（此消息字段仅为示意，具体字段需要与服务器协商），主动断开连接
    if (value === 'bye') {
        ws.close((err, value) => {
            if (!err) {
                console.log("Connection closed successfully");
            } else {
                console.log("Failed to close the connection. Err: " + JSON.stringify(err));
            }
        });
    }
});
ws.on('close', (err, value) => {
    console.log("on close, code is " + value.code + ", reason is " + value.reason);
});
ws.on('error', (err) => {
    console.log("on error, error:" + JSON.stringify(err));
});
ws.connect(defaultIpAddress, (err, value) => {
    if (!err) {
        console.log("Connected successfully");
    } else {
        console.log("Connection failed. Err:" + JSON.stringify(err));
    }
});

import socket from '@ohos.net.socket'

// 创建一个TCPSocket连接，返回一个TCPSocket对象。
let tcp = socket.constructTCPSocketInstance();

// 订阅TCPSocket相关的订阅事件
tcp.on('message', value => {
    console.log("on message")
    let buffer = value.message
    let dataView = new DataView(buffer)
    let str = ""
    for (let i = 0;i < dataView.byteLength; ++i) {
        str += String.fromCharCode(dataView.getUint8(i))
    }
    console.log("on connect received:" + str)
});
tcp.on('connect', () => {
    console.log("on connect")
});
tcp.on('close', () => {
    console.log("on close")
});

// 绑定本地IP地址和端口。
let bindAddress = {
    address: '192.168.xx.xx',
    port: 1234, // 绑定端口，如1234
    family: 1
};
tcp.bind(bindAddress, err => {
    if (err) {
        console.log('bind fail');
        return;
    }
    console.log('bind success');
    // 连接到指定的IP地址和端口。
    let connectAddress = {
        address: '192.168.xx.xx',
        port: 5678, // 连接端口，如5678
        family: 1
    };
    tcp.connect({
        address: connectAddress, timeout: 6000
    }, err => {
        if (err) {
            console.log('connect fail');
            return;
        }
        console.log('connect success');
        // 发送数据
        tcp.send({
            data: 'Hello, server!'
        }, err => {
            if (err) {
                console.log('send fail');
                return;
            }
            console.log('send success');
        })
    });
});
// 连接使用完毕后，主动关闭。取消相关事件的订阅。
setTimeout(() => {
    tcp.close((err) => {
        console.log('close socket.')
    });
    tcp.off('message');
    tcp.off('connect');
    tcp.off('close');
}, 30 * 1000);

class ITestAbility : public IRemoteBroker {
public:
    // DECLARE_INTERFACE_DESCRIPTOR是必需的，入参需使用std::u16string；
    DECLARE_INTERFACE_DESCRIPTOR("test.ITestAbility");
    int TRANS_ID_PING_ABILITY = 1; // 定义消息码
    virtual int TestPingAbility(const std::u16string &dummy) = 0; // 定义业务函数
};

class TestAbilityStub : public IRemoteStub<ITestAbility> {
public:    
    virtual int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
    int TestPingAbility(const std::u16string &dummy) override;
 };

int TestServiceStub::OnRemoteRequest(uint32_t code,
    MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    switch (code) {
        case TRANS_ID_PING_ABILITY: {
            std::u16string dummy = data.ReadString16();
            int result = TestPingAbility(dummy);
            reply.WriteInt32(result);
            return 0;
        }
        default:
            return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
    }
}

class TestAbility : public TestAbilityStub {
public:
    int TestPingAbility(const std::u16string &dummy);
}

int TestAbility::TestPingAbility(const std::u16string &dummy) {
    return 0;
}

class TestAbilityProxy : public IRemoteProxy<ITestAbility> {
public:
    explicit TestAbilityProxy(const sptr<IRemoteObject> &impl);
    int TestPingService(const std::u16string &dummy) override;
private:
    static inline BrokerDelegator<TestAbilityProxy> delegator_; // 方便后续使用iface_cast宏
}

TestAbilityProxy::TestAbilityProxy(const sptr<IRemoteObject> &impl)
    : IRemoteProxy<ITestAbility>(impl)
{
}

int TestAbilityProxy::TestPingService(const std::u16string &dummy){
    MessageOption option;
    MessageParcel dataParcel, replyParcel;
    dataParcel.WriteString16(dummy);
    int error = Remote()->SendRequest(TRANS_ID_PING_ABILITY, dataParcel, replyParcel, option);
    int result = (error == ERR_NONE) ? replyParcel.ReadInt32() : -1;
    return result;
 }

// 注册到本设备内
auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
samgr->AddSystemAbility(saId, new TestAbility());

// 在组网场景下，会被同步到其他设备上
auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
ISystemAbilityManager::SAExtraProp saExtra;
saExtra.isDistributed = true; // 设置为分布式SA
int result = samgr->AddSystemAbility(saId, new TestAbility(), saExtra);

// 获取本设备内注册的SA的proxy
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(saId);
sptr<ITestAbility> testAbility = iface_cast<ITestAbility>(remoteObject); // 使用iface_cast宏转换成具体类型

// 获取其他设备注册的SA的proxy
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(saId, deviceId); // deviceId是指定设备的标识符
sptr<TestAbilityProxy> proxy(new TestAbilityProxy(remoteObject)); // 直接构造具体Proxy

class TestDeathRecipient : public IRemoteObject::DeathRecipient {
public:
    virtual void OnRemoteDied(const wptr<IRemoteObject>& remoteObject);
}
sptr<IRemoteObject::DeathRecipient> deathRecipient (new TestDeathRecipient());// 构造一个死亡通知对象
bool result = proxy->AddDeathRecipient(deathRecipient); // 注册死亡通知
result = proxy->RemoveDeathRecipient(deathRecipient); // 移除死亡通知

// import需要的模块
import call from '@ohos.telephony.call';
import observer from '@ohos.telephony.observer';

// 调用查询能力接口
let isSupport = call.hasVoiceCapability();
if (!isSupport) {
    console.log("not support voice capability, return.");
}
// 如果设备支持呼叫能力，则继续跳转到拨号界面，并显示拨号的号码
call.makeCall("13xxxx", (err)=> {
    if (!err) {
        console.log("make call success.");
    } else {
        console.log("make call fail, err is:" + JSON.stringify(err));
    }
});
// 订阅通话业务状态变化（可选）
observer.on("callStateChange", (data) => {
    console.log("call state change, data is:" + JSON.stringify(data));
});

import radio from '@ohos.telephony.radio'
import observer from '@ohos.telephony.observer';

// 以获取卡1的信号强度为例
let slotId = 0;
radio.getSignalInformation(slotId, (err, data) => {
    if (!err) {
        console.log("get signal information success.");
        // 遍历数组，输出不同网络制式下的信号强度
        for (let j = 0; j < data.length; j++) {
            console.log("type:" + data[j].signalType + ", level:" + data[j].signalLevel);
        }
    } else {
        console.log("get signal information fail, err is:" + JSON.stringify(err));
    }
});
// 订阅蜂窝网络信号变化（可选）
observer.on("signalInfoChange", (data) => {
    console.log("signal info change, data is:" + JSON.stringify(data));
});