js/ServiceAbility/service.js

/*
 * Copyright (C) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import notification from '@ohos.notification';
import featureAbility from '@ohos.ability.featureAbility';
import wantAgent from '@ohos.wantAgent';
import backgroundTaskManager from '@ohos.backgroundTaskManager';
import resBackgroundTaskManager from '@ohos.resourceschedule.backgroundTaskManager';
import particleAbility from '@ohos.ability.particleAbility';
import commonEvent from '@ohos.commonEvent';

const TAG = 'BGMODE_TEST ';

let event;

let request = {
    content: {
        contentType: notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
        normal: {
            title: 'title',
            text: 'text'
        }
    },
    id: 1
};

let wantAgentInfo = {
    wants: [
        {
            bundleName: 'ohos.acts.resourceschedule.taskmgr.js.function',
            abilityName: 'ohos.acts.resourceschedule.taskmgr.js.function.MainAbility'
        }
    ],
    operationType: wantAgent.OperationType.START_ABILITY,
    requestCode: 0,
    wantAgentFlags: [wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG]
};

function callback(err, data) {
    if (err) {
        console.error(TAG + ' Operation failed');
    } else {
        console.info(TAG + ' Operation succeed');
        commonEvent.publish(event, (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    }
}

function startContinuousTaskUseApi7Callback() {
    event = 'startTaskUseApi7Callback';
    particleAbility.startBackgroundRunning(1, request, callback);
}

function stopContinuousTaskUseApi7Callback() {
    event = 'stopTaskUseApi7Callback';
    particleAbility.startBackgroundRunning(1, request).then(() => {
        particleAbility.cancelBackgroundRunning(callback);
    });
}

function startContinuousTaskUseApi8Callback() {
    event = 'startTaskUseApi8Callback';
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        backgroundTaskManager.startBackgroundRunning(featureAbility.getContext(),
            backgroundTaskManager.BackgroundMode.LOCATION, data, callback);
    });
}

function stopContinuousTaskUseApi8Callback() {
    event = 'stopTaskUseApi8Callback';
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        return backgroundTaskManager.startBackgroundRunning(featureAbility.getContext(),
            backgroundTaskManager.BackgroundMode.LOCATION, data);
    }).then(() => {
        backgroundTaskManager.stopBackgroundRunning(featureAbility.getContext(), callback);
    });
}

function startContinuousTaskUseApi7Promise() {
    particleAbility.startBackgroundRunning(1, request).then(() => {
        commonEvent.publish('startTaskUseApi7Promise', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    });
}

function stopContinuousTaskUseApi7Promise() {
    particleAbility.startBackgroundRunning(1, request).then(() => {
        return particleAbility.cancelBackgroundRunning();
    }).then(() => {
        commonEvent.publish('stopTaskUseApi7Promise', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    });
}

function startContinuousTaskUseApi8Promise() {
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        return backgroundTaskManager.startBackgroundRunning(featureAbility.getContext(),
            backgroundTaskManager.BackgroundMode.LOCATION, data);
    }).then(() => {
        commonEvent.publish('startTaskUseApi8Promise', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    });
}

function stopContinuousTaskUseApi8Promise() {
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        return backgroundTaskManager.startBackgroundRunning(featureAbility.getContext(),
            backgroundTaskManager.BackgroundMode.LOCATION, data);
    }).then(() => {
        return backgroundTaskManager.stopBackgroundRunning(featureAbility.getContext());
    }).then(() => {
        commonEvent.publish('stopTaskUseApi8Promise', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        })
    });
}

function startContinuousTaskInvalidBgmode() {
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        return backgroundTaskManager.startBackgroundRunning(featureAbility.getContext(),
            backgroundTaskManager.BackgroundMode.BLUETOOTH_INTERACTION, data);
    }).catch(() => {
        commonEvent.publish('startTaskInvalidBgmode', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    });
}

function updateContinuousTaskUseApi12Promise() {
    let list = ['audioPlayback', 'location'];
    wantAgent.getWantAgent(wantAgentInfo).then((data) => {
        return resBackgroundTaskManager.updateBackgroundRunning(featureAbility.getContext(),
            list, data);
    }).catch(() => {
        commonEvent.publish('updateTaskUseApi12Promise', (err) => {
            if (err.code) {
                console.error(TAG + 'PublishCallBack failed');
            } else {
                console.info(TAG + 'Publish succeed');
            }
        });
    });
}

function handleOption(want) {
    switch (want.parameters.option) {
        case 'testcase1':
            startContinuousTaskUseApi7Callback();
            break;
        case 'testcase2':
            stopContinuousTaskUseApi7Callback();
            break;
        case 'testcase3':
            startContinuousTaskUseApi8Callback();
            break;
        case 'testcase4':
            stopContinuousTaskUseApi8Callback();
            break;
        case 'testcase5':
            startContinuousTaskUseApi7Promise();
            break;
        case 'testcase6':
            stopContinuousTaskUseApi7Promise();
            break;
        case 'testcase7':
            startContinuousTaskUseApi8Promise();
            break;
        case 'testcase8':
            stopContinuousTaskUseApi8Promise();
            break;
        case 'testcase9':
            startContinuousTaskInvalidBgmode();
            break;
        case 'testcase10':
            updateContinuousTaskUseApi12Promise();
            break;
        default:
            console.warn(TAG + 'Unknown option');
            break;
    }
}

export default {
    onStart() {
        console.info(TAG + 'ServiceAbility onStart');
    },
    onStop() {
        console.info(TAG + 'ServiceAbility onStop');
    },
    onCommand(want, startId) {
        console.info(TAG + 'ServiceAbility onCommand');
        console.info(TAG + 'Get onCommand want: ' + JSON.stringify(want));
        particleAbility.cancelBackgroundRunning();
        backgroundTaskManager.stopBackgroundRunning(featureAbility.getContext());
        handleOption(want);
    },
    onConnect(want) {
        console.info(TAG + 'ServiceAbility onConnect');
    },
    onDisConnect(want) {
        console.info(TAG + 'ServiceAbility onDisConnect');
    },
};